def rpn_rois(self, gt_boxes, labels):
self.proposals = tf.Print(self.proposals, [tf.shape(self.proposals)], message='proposal shape')
filled_gt_boxes = tf.concat(1, [tf.zeros([tf.shape(gt_boxes)[0], 1], dtype=tf.float32), gt_boxes])
all_rois = tf.concat(0, [self.proposals, filled_gt_boxes])
overlaps = self._calculate_overlaps(all_rois[:, 1:5], gt_boxes)
# because faster-rcnn process one image per batch, leave the num_images here to keep consistency.
num_images = 1
rois_per_image = tf.constant(cfg.TRAIN.BATCH_SIZE / num_images, dtype=tf.float32)
fg_rois_per_image = tf.cast(tf.round(cfg.TRAIN.FG_FRACTION * rois_per_image), dtype=tf.int32)
gt_assignment = tf.arg_max(overlaps, dimension=1)
max_overlaps = tf.reduce_max(overlaps, reduction_indices=1)
labels = tf.gather(labels, gt_assignment)
fg_inds = tf.reshape(tf.cast(tf.where(max_overlaps >= cfg.TRAIN.FG_THRESH), dtype=tf.int32), [-1, ])
fg_rois_this_image = tf.minimum(fg_rois_per_image, tf.shape(fg_inds)[0])
# TODO: Check if fg_inds.size > 0:
fg_inds = tf.random_crop(fg_inds, size=[fg_rois_this_image])
bg_inds = tf.reshape(tf.cast(tf.where((max_overlaps < cfg.TRAIN.BG_THRESH_HI) &
(max_overlaps >= cfg.TRAIN.BG_THRESH_LO)),
dtype=tf.int32),
[-1, ])
bg_rois_this_image = tf.minimum(tf.cast(rois_per_image, dtype=tf.int32) - fg_rois_this_image, tf.shape(bg_inds)[0])
# TODO: Check if bg_inds.size > 0:
bg_inds = tf.random_crop(bg_inds, size=[bg_rois_this_image])
keep_inds = tf.concat(0, [fg_inds, bg_inds])
self.train_labels = tf.concat(0, (tf.gather(labels, fg_inds), tf.zeros((tf.shape(bg_inds)[0],), dtype=tf.int32)))
self.train_rois = tf.gather(all_rois, keep_inds)
bbox_target_data = self._compute_targets(
self.train_rois[:, 1:5], tf.gather(gt_boxes, tf.gather(gt_assignment, keep_inds)), self.train_labels)
return self.train_rois, self.train_labels, bbox_target_data
# TODO: implement this
# self.bbox_targets, self.bbox_inside_weights = \
# self._get_bbox_regression_labels(bbox_target_data, num_classes)
python类Print()的实例源码
def _filter_top_n(self, proposals, scores):
order = tf.py_func(arg_sort_op, [tf.reshape(scores, (-1,))], [tf.int64])[0]
if self._debug:
order = tf.Print(order, [tf.shape(order), tf.shape(proposals), tf.shape(scores)], message='order shape: ')
if self._pre_nms_top_n > 0:
order = tf.gather(order, tf.range(0, self._pre_nms_top_n))
proposals = tf.gather(proposals, order)
scores = tf.gather(scores, order)
return proposals, scores
def meanShift(n_updates=-1):
X1 = tf.expand_dims(tf.transpose(input_X), 0)
X2 = tf.expand_dims(input_X, 0)
C = init_C
sbs_C = tf.TensorArray(dtype=tf.float32, size=10000, infer_shape=False)
sbs_C = sbs_C.write(0, init_C)
def _mean_shift_step(C):
C = tf.expand_dims(C, 2)
Y = tf.reduce_sum(tf.pow((C - X1) / window_radius, 2), axis=1)
gY = tf.exp(-Y)
num = tf.reduce_sum(tf.expand_dims(gY, 2) * X2, axis=1)
denom = tf.reduce_sum(gY, axis=1, keep_dims=True)
C = num / denom
return C
if n_updates > 0:
for i in range(n_updates):
C = _mean_shift_step(C)
sbs_C = sbs_C.write(i + 1, C)
else:
def _mean_shift(i, C, sbs_C, max_diff):
new_C = _mean_shift_step(C)
max_diff = tf.reshape(tf.reduce_max(tf.sqrt(tf.reduce_sum(tf.pow(new_C - C, 2), axis=1))), [])
sbs_C = sbs_C.write(i + 1, new_C)
return i + 1, new_C, sbs_C, max_diff
def _cond(i, C, sbs_C, max_diff):
return max_diff > 1e-5
n_updates, C, sbs_C, _ = tf.while_loop(cond=_cond,
body=_mean_shift,
loop_vars=(tf.constant(0), C, sbs_C, tf.constant(1e10)))
n_updates = tf.Print(n_updates, [n_updates])
return C, sbs_C.gather(tf.range(n_updates + 1))
def _max_pool(bottom, name, debug):
pool = tf.nn.max_pool(bottom, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME', name=name)
print('Layer name: %s' % name)
print('Layer shape:%s' % str(pool.get_shape()))
if debug:
pool = tf.Print(pool, [pool.get_shape()],
message='Shape of %s' % name,
summarize=4, first_n=1)
_activation_summary(pool)
return pool
def _upscore_layer(bottom, shape, num_classes, name, debug, ksize=4, stride=2):
strides = [1, stride, stride, 1]
with tf.variable_scope(name) :
in_features = bottom.get_shape()[3].value
if shape is None:
# Compute shape out of Bottom
in_shape = bottom.get_shape()
h = ((in_shape[1] - 1) * stride) + 1
w = ((in_shape[2] - 1) * stride) + 1
new_shape = [in_shape[0], h, w, num_classes]
else:
new_shape = [shape[0], shape[1], shape[2], num_classes]
output_shape = tf.pack(new_shape)
logging.debug("Layer: %s, Fan-in: %d" % (name, in_features))
f_shape = [ksize, ksize, num_classes, in_features]
weights = get_deconv_filter(f_shape)
deconv = tf.nn.conv2d_transpose(bottom, weights, output_shape,
strides=strides, padding='SAME')
deconv.set_shape(new_shape)
print('Layer name: %s' % name)
print('Layer shape: %s' % str(deconv.get_shape()))
if debug:
deconv = tf.Print(deconv, [deconv.get_shape()],
message='Shape of %s' % name,
summarize=4, first_n=1)
_activation_summary(deconv)
return deconv
def get_lstm_layers(features, timesteps, batch_size):
with tf.variable_scope('RNN'):
# Has size [batch_size, max_stepsize, num_features], but the
# batch_size and max_stepsize can vary along each step
#tf.placeholder(tf.float32, [None, None, ocr_input.IMAGE_HEIGHT])
inputs = features
shape = tf.shape(features)
batch_size, max_timesteps = shape[0], shape[1]
# Defining the cell
# Can be:
# tf.nn.rnn_cell.RNNCell
# tf.nn.rnn_cell.GRUCell
cell = tf.contrib.rnn.core_rnn_cell.LSTMCell(LSTM_HIDDEN_SIZE, state_is_tuple=True)
# Stacking rnn cells
stack = tf.contrib.rnn.core_rnn_cell.MultiRNNCell([cell] * NUM_LSTM_LAYERS,
state_is_tuple=True)
# The second output is the last state and we will no use that
outputs, _ = tf.nn.dynamic_rnn(stack, inputs, timesteps, dtype=tf.float32)
# Reshaping to apply the same weights over the timesteps
outputs = tf.reshape(outputs, [-1, LSTM_HIDDEN_SIZE])
# outputs = tf.Print(outputs, [outputs], "Outputs")
with tf.variable_scope('logits'):
w = tf.Variable(tf.truncated_normal([LSTM_HIDDEN_SIZE,
NUM_CLASSES],
stddev=0.1), name="w")
b = tf.Variable(tf.constant(0., shape=[NUM_CLASSES]), name="b")
# Doing the affine projection
logits = tf.matmul(outputs, w) + b
# Reshaping back to the original shape
logits = tf.reshape(logits, [batch_size, -1, NUM_CLASSES])
logits = tf.transpose(logits, [1, 0, 2], name="out_logits")
return logits
def check_decoder(logits, labels, timesteps):
with tf.variable_scope('check_decoder'):
decoded, log_prob = tf.nn.ctc_greedy_decoder(logits, timesteps)
decoded = tf.cast(decoded[0], tf.int32)
decoded = tf.sparse_tensor_to_dense(decoded)
# decoded = tf.Print(decoded, [decoded], "Decoded")
return decoded
def print_tensor_summary(tensor, tag=None, n_print=21):
tensor_min = tf.reduce_min(tensor)
tensor_max = tf.reduce_max(tensor)
tensor_avg = tf.reduce_mean(tensor)
tensor_zero_fraction = tf.nn.zero_fraction(tensor)
tensor_shape = tf.shape(tensor)
tag = tag or tensor.name
tensor = tf.Print(tensor,
[tensor_min, tensor_max, tensor_avg, tensor_zero_fraction, tensor_shape, tensor],
message=(tag + ' Min, max, mean, sparsity, shape, value:'),
summarize=n_print)
return tensor
def print_tensor(x, message=''):
'''Print the message and the tensor when evaluated and return the same
tensor.
'''
return tf.Print(x, [x], message)
# GRAPH MANIPULATION
def _apply_stats(self, statsUpdates, accumulate=False, accumulateCoeff=0.):
updateOps = []
# obtain the stats var list
for stats_var in statsUpdates:
stats_new = statsUpdates[stats_var]
if accumulate:
# simple superbatch averaging
update_op = tf.assign_add(
stats_var, accumulateCoeff * stats_new, use_locking=True)
else:
# exponential running averaging
update_op = tf.assign(
stats_var, stats_var * self._stats_decay, use_locking=True)
update_op = tf.assign_add(
update_op, (1. - self._stats_decay) * stats_new, use_locking=True)
updateOps.append(update_op)
with tf.control_dependencies(updateOps):
stats_step_op = tf.assign_add(self.stats_step, 1)
if KFAC_DEBUG:
stats_step_op = (tf.Print(stats_step_op,
[tf.convert_to_tensor('step:'),
self.global_step,
tf.convert_to_tensor('fac step:'),
self.factor_step,
tf.convert_to_tensor('sgd step:'),
self.sgd_step,
tf.convert_to_tensor('Accum:'),
tf.convert_to_tensor(accumulate),
tf.convert_to_tensor('Accum coeff:'),
tf.convert_to_tensor(accumulateCoeff),
tf.convert_to_tensor('stat step:'),
self.stats_step, updateOps[0], updateOps[1]]))
return [stats_step_op, ]
def applyStatsEigen(self, eigen_list):
updateOps = []
print(('updating %d eigenvalue/vectors' % len(eigen_list)))
for i, (tensor, mark) in enumerate(zip(eigen_list, self.eigen_update_list)):
stats_eigen_var = self.eigen_reverse_lookup[mark]
updateOps.append(
tf.assign(stats_eigen_var, tensor, use_locking=True))
with tf.control_dependencies(updateOps):
factor_step_op = tf.assign_add(self.factor_step, 1)
updateOps.append(factor_step_op)
if KFAC_DEBUG:
updateOps.append(tf.Print(tf.constant(
0.), [tf.convert_to_tensor('updated kfac factors')]))
return updateOps
def apply_gradients(self, grads):
coldOptim = tf.train.MomentumOptimizer(
self._cold_lr, self._momentum)
def coldSGDstart():
sgd_grads, sgd_var = zip(*grads)
if self.max_grad_norm != None:
sgd_grads, sgd_grad_norm = tf.clip_by_global_norm(sgd_grads,self.max_grad_norm)
sgd_grads = list(zip(sgd_grads,sgd_var))
sgd_step_op = tf.assign_add(self.sgd_step, 1)
coldOptim_op = coldOptim.apply_gradients(sgd_grads)
if KFAC_DEBUG:
with tf.control_dependencies([sgd_step_op, coldOptim_op]):
sgd_step_op = tf.Print(
sgd_step_op, [self.sgd_step, tf.convert_to_tensor('doing cold sgd step')])
return tf.group(*[sgd_step_op, coldOptim_op])
kfacOptim_op, qr = self.apply_gradients_kfac(grads)
def warmKFACstart():
return kfacOptim_op
return tf.cond(tf.greater(self.sgd_step, self._cold_iter), warmKFACstart, coldSGDstart), qr
def detectMinVal(input_mat, var, threshold=1e-6, name='', debug=False):
eigen_min = tf.reduce_min(input_mat)
eigen_max = tf.reduce_max(input_mat)
eigen_ratio = eigen_max / eigen_min
input_mat_clipped = clipoutNeg(input_mat, threshold)
if debug:
input_mat_clipped = tf.cond(tf.logical_or(tf.greater(eigen_ratio, 0.), tf.less(eigen_ratio, -500)), lambda: input_mat_clipped, lambda: tf.Print(
input_mat_clipped, [tf.convert_to_tensor('screwed ratio ' + name + ' eigen values!!!'), tf.convert_to_tensor(var.name), eigen_min, eigen_max, eigen_ratio]))
return input_mat_clipped
def __call__(self, enc_input, dec_input_indices, valid_indices, left_indices, right_indices, values, valid_masks=None):
batch_size = tf.shape(enc_input)[0]
# forward computation graph
with tf.variable_scope(self.scope):
# encoder output
enc_memory, enc_final_state_fw, _ = self.encoder(enc_input)
# decoder
dec_hiddens, dec_actions, dec_act_logps = self.decoder(
enc_memory, dec_input_indices,
valid_indices, left_indices, right_indices,
valid_masks, init_state=enc_final_state_fw)
# cost
costs = []
update_ops = []
for step_idx, (act_logp, value, baseline) in enumerate(zip(dec_act_logps, values, self.baselines)):
# costs.append(-tf.reduce_mean(act_logp * (value - baseline)))
new_baseline = self.bl_ratio * baseline + (1-self.bl_ratio) * tf.reduce_mean(value)
costs.append(-tf.reduce_mean(act_logp * value))
update_ops.append(tf.assign(baseline, new_baseline))
# gradient computation graph
self.params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.scope)
train_ops = []
for limit in self.buckets:
print '0 ~ %d' % (limit-1)
grad_params = tf.gradients(tf.reduce_sum(tf.pack(costs[:limit])), self.params)
if self.max_grad_norm is not None:
clipped_gradients, norm = tf.clip_by_global_norm(grad_params, self.max_grad_norm)
else:
clipped_gradients = grad_params
train_op = self.optimizer.apply_gradients(
zip(clipped_gradients, self.params))
with tf.control_dependencies([train_op] + update_ops[:limit]):
# train_ops.append(tf.Print(tf.constant(1.), [norm]))
train_ops.append(tf.constant(1.))
return dec_hiddens, dec_actions, train_ops
#### test script
def __call__(self, inputs, state, scope=None):
with tf.variable_scope(scope or type(self).__name__, initializer=self._initializer):
# Split the hidden state into blocks (each U, V, W are shared across blocks).
# U = tf.get_variable('U', [self._num_units_per_block, self._num_units_per_block],
# initializer= tf.constant_initializer(np.identity(self._num_units_per_block)),
# trainable = False)
# W = tf.get_variable('W', [self._num_units_per_block, self._num_units_per_block],
# initializer = tf.constant_initializer(np.zeros(self._num_units_per_block, self._num_units_per_block)),
# trainable = False)
# V = tf.get_variable('V', [self._num_units_per_block, self._num_units_per_block],
# initializer = tf.constant_initializer(np.zeros(self._num_units_per_block, self._num_units_per_block)),
# trainable = False)
# b = tf.get_variable('biasU',[self._num_units_per_block])
# self._q = tf.Print(self._q, [self._q],summarize=10)
# TODO: layer norm?
state = tf.split(state, self._num_blocks, 1)
next_states = []
for j, state_j in enumerate(state): # Hidden State (j)
key_j = self._keys[j]
gate_j = self.get_gate(state_j, key_j, inputs)
candidate_j = inputs
# Equation 4: h_j <- h_j + g_j * h_j^~
# Perform an update of the hidden state (memory).
state_j_next = state_j + tf.expand_dims(gate_j, -1) * candidate_j
# # Forget previous memories by normalization.
# state_j_next = tf.nn.l2_normalize(state_j_next, -1) # TODO: Is epsilon necessary?
next_states.append(state_j_next)
state_next = tf.concat(next_states, 1)
return state_next, state_next
def ornstein_uhlenbeck_noise(a, t_decay=100000):
noise_var = get_local_variable("nm", initializer=tf.zeros(a.get_shape()[1:]))
ou_theta = get_local_variable("ou_theta", initializer=0.2)
ou_sigma = get_local_variable("ou_sigma", initializer=0.15)
# ou_theta = tf.Print(ou_theta, [noise_var], 'noise: ', first_n=2000)
ou_sigma = tf.train.exponential_decay(ou_sigma, tt.function.step(), t_decay, 1e-6)
n = noise_var.assign_sub(ou_theta * noise_var - tf.random_normal(a.get_shape()[1:], stddev=ou_sigma))
return a + n
def build(self, predictions, targets, inputs=None):
""" Prints the number of each kind of prediction """
self.built = True
pshape = predictions.get_shape()
self.inner_metric.build(predictions, targets, inputs)
with tf.name_scope(self.name):
if len(pshape) == 1 or (len(pshape) == 2 and int(pshape[1]) == 1):
self.name = self.name or "binary_prediction_counts"
y, idx, count = tf.unique_with_counts(tf.argmax(predictions))
self.tensor = tf.Print(self.inner_metric, [y, count], name=self.inner_metric.name)
else:
self.name = self.name or "categorical_prediction_counts"
y, idx, count = tf.unique_with_counts(tf.argmax(predictions, dimension=1))
self.tensor = tf.Print(self.inner_metric.tensor, [y, count], name=self.inner_metric.name)
def test_basic(self):
with tf.Graph().as_default(), self.test_session() as sess:
rnd = np.random.RandomState(0)
x = self.get_random_tensor([18, 12], rnd=rnd)
y = tf.Print(x, [x])
self.assert_bw_fw(sess, x, y, rnd=rnd)
def init_ops_for_training(self, target_critic):
# update critic using bellman equation; Q(s1, a) = reward + discount * Q(s2, A(s2))
# left hand side of bellman is just q_value, but let's be explicit about it...
bellman_lhs = self.q_value
# right hand side is ...
# = reward + discounted q value from target actor & critic in the non terminal case
# = reward # in the terminal case
self.reward = tf.placeholder(shape=[None, 1], dtype=tf.float32, name="critic_reward")
self.terminal_mask = tf.placeholder(shape=[None, 1], dtype=tf.float32,
name="critic_terminal_mask")
self.input_state_2 = target_critic.input_state
bellman_rhs = self.reward + (self.terminal_mask * opts.discount * target_critic.q_value)
# note: since we are NOT training target networks we stop gradients flowing to them
bellman_rhs = tf.stop_gradient(bellman_rhs)
# the value we are trying to mimimise is the difference between these two; the
# temporal difference we use a squared loss for optimisation and, as for actor, we
# wrap optimiser in a namespace so it's not picked up by target network variable
# handling.
self.temporal_difference = bellman_lhs - bellman_rhs
self.temporal_difference_loss = tf.reduce_mean(tf.pow(self.temporal_difference, 2))
# self.temporal_difference_loss = tf.Print(self.temporal_difference_loss, [self.temporal_difference_loss], 'temporal_difference_loss')
with tf.variable_scope("optimiser"):
# calc gradients
optimiser = tf.train.GradientDescentOptimizer(opts.critic_learning_rate)
gradients = optimiser.compute_gradients(self.temporal_difference_loss)
# potentially clip and wrap with debugging tf.Print
gradients = util.clip_and_debug_gradients(gradients, opts)
# apply
self.train_op = optimiser.apply_gradients(gradients)
def clip_and_debug_gradients(gradients, opts):
# extract just the gradients temporarily for global clipping and then rezip
if opts.gradient_clip is not None:
just_gradients, variables = zip(*gradients)
just_gradients, _ = tf.clip_by_global_norm(just_gradients, opts.gradient_clip)
gradients = zip(just_gradients, variables)
# verbose debugging
if opts.print_gradients:
for i, (gradient, variable) in enumerate(gradients):
if gradient is not None:
gradients[i] = (tf.Print(gradient, [l2_norm(gradient)],
"gradient %s l2_norm " % variable.name), variable)
# done
return gradients
