def thresholding(inputs):
# find the mean for each example in the batch
mean_output = tf.reduce_mean(inputs, axis=1)
# scale each mean based on a factor
threshold_scalar = tf.Variable(utils.threshold_scalar, tf.float32)
scaled_mean = tf.scalar_mul(threshold_scalar, mean_output)
scaled_mean = tf.reshape(scaled_mean, [utils.batch_size])
# setup matrix for
min_thresh_for_max = tf.fill([utils.batch_size], 0.05)
max_thresh_for_min = tf.fill([utils.batch_size], 0.15) #0.4
thresholds = tf.maximum(min_thresh_for_max, scaled_mean)
thresholds = tf.minimum(max_thresh_for_min, thresholds)
# zero values under the thresholds using bitmask
thresholds = tf.reshape(thresholds, [128, 1, 1])
threshold_mask = tf.cast(tf.greater(inputs, thresholds), tf.float32)
thresholded_input = tf.multiply(inputs, threshold_mask)
# peak picking
# select beats by x[i-1] < x[i] > x[i+1] (local maximum)
x_minus_1 = tf.cast(tf.greater(thresholded_input, tf.manip.roll(thresholded_input, shift=-1, axis=1)), tf.float32)
x_plus_1 = tf.cast(tf.greater(thresholded_input, tf.manip.roll(thresholded_input, shift=1, axis=1)), tf.float32)
output = tf.multiply(x_minus_1, x_plus_1)
return output
def IoULoss(self, pd, gt):
mask = tf.cast(
tf.greater(tf.reduce_sum(
tf.cast(tf.greater(gt, 0), tf.int8), 3), 3),
tf.float32
)
npd = tf.transpose(pd, [3, 0, 1, 2])
ngt = tf.transpose(gt, [3, 0, 1, 2])
area_x = tf.mul(
tf.add(tf.gather(npd, 0), tf.gather(npd, 2)),
tf.add(tf.gather(npd, 1), tf.gather(npd, 3)),
)
area_g = tf.mul(
tf.add(tf.gather(ngt, 0), tf.gather(ngt, 2)),
tf.add(tf.gather(ngt, 1), tf.gather(ngt, 3)),
)
w_overlap = tf.maximum(tf.constant(0, tf.float32), tf.add(
tf.minimum(tf.gather(npd, 0), tf.gather(ngt, 0)),
tf.minimum(tf.gather(npd, 2), tf.gather(ngt, 2)),
))
h_overlap = tf.maximum(tf.constant(0, tf.float32), tf.add(
tf.minimum(tf.gather(npd, 1), tf.gather(ngt, 1)),
tf.minimum(tf.gather(npd, 3), tf.gather(ngt, 3)),
))
area_overlap = tf.mul(w_overlap, h_overlap)
area_u = tf.sub(tf.add(area_x, area_g), area_overlap)
iou = tf.div(area_overlap, tf.add(area_u, tf.constant(1, tf.float32)))
iou = tf.maximum(iou, tf.constant(1e-4, tf.float32))
cost = -tf.log(iou)
cost = tf.mul(cost, mask)
cost = tf.reduce_sum(cost)
return cost
def set_logp_to_neg_inf(X, logp, bounds):
"""Set `logp` to negative infinity when `X` is outside the allowed bounds.
# Arguments
X: tensorflow.Tensor
The variable to apply the bounds to
logp: tensorflow.Tensor
The log probability corrosponding to `X`
bounds: list of `Region` objects
The regions corrosponding to allowed regions of `X`
# Returns
logp: tensorflow.Tensor
The newly bounded log probability
"""
conditions = []
for l, u in bounds:
lower_is_neg_inf = not isinstance(l, tf.Tensor) and np.isneginf(l)
upper_is_pos_inf = not isinstance(u, tf.Tensor) and np.isposinf(u)
if not lower_is_neg_inf and upper_is_pos_inf:
conditions.append(tf.greater(X, l))
elif lower_is_neg_inf and not upper_is_pos_inf:
conditions.append(tf.less(X, u))
elif not (lower_is_neg_inf or upper_is_pos_inf):
conditions.append(tf.logical_and(tf.greater(X, l), tf.less(X, u)))
if len(conditions) > 0:
is_inside_bounds = conditions[0]
for condition in conditions[1:]:
is_inside_bounds = tf.logical_or(is_inside_bounds, condition)
logp = tf.select(is_inside_bounds, logp, tf.fill(tf.shape(X), config.dtype(-np.inf)))
return logp
def get_losses(obj_mask):
"""Get motion constraint loss."""
# Find height of segment.
coords = tf.where(tf.greater( # Shape (num_true, 2=yx)
obj_mask[:, :, 0], tf.constant(0.5, dtype=tf.float32)))
y_max = tf.reduce_max(coords[:, 0])
y_min = tf.reduce_min(coords[:, 0])
seg_height = y_max - y_min
f_y = self.intrinsic_mat[i, 0, 1, 1]
approx_depth = ((f_y * self.global_scale_var) /
tf.to_float(seg_height))
reference_pred = tf.boolean_mask(
depth_pred, tf.greater(
tf.reshape(obj_mask[:, :, 0],
(self.img_height, self.img_width, 1)),
tf.constant(0.5, dtype=tf.float32)))
# Establish loss on approx_depth, a scalar, and
# reference_pred, our dense prediction. Normalize both to
# prevent degenerative depth shrinking.
global_mean_depth_pred = tf.reduce_mean(depth_pred)
reference_pred /= global_mean_depth_pred
approx_depth /= global_mean_depth_pred
spatial_err = tf.abs(reference_pred - approx_depth)
mean_spatial_err = tf.reduce_mean(spatial_err)
return mean_spatial_err
def prune_outside_window(boxlist, window, scope=None):
"""Prunes bounding boxes that fall outside a given window.
This function prunes bounding boxes that even partially fall outside the given
window. See also clip_to_window which only prunes bounding boxes that fall
completely outside the window, and clips any bounding boxes that partially
overflow.
Args:
boxlist: a BoxList holding M_in boxes.
window: a float tensor of shape [4] representing [ymin, xmin, ymax, xmax]
of the window
scope: name scope.
Returns:
pruned_corners: a tensor with shape [M_out, 4] where M_out <= M_in
valid_indices: a tensor with shape [M_out] indexing the valid bounding boxes
in the input tensor.
"""
with tf.name_scope(scope, 'PruneOutsideWindow'):
y_min, x_min, y_max, x_max = tf.split(
value=boxlist.get(), num_or_size_splits=4, axis=1)
win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
coordinate_violations = tf.concat([
tf.less(y_min, win_y_min), tf.less(x_min, win_x_min),
tf.greater(y_max, win_y_max), tf.greater(x_max, win_x_max)
], 1)
valid_indices = tf.reshape(
tf.where(tf.logical_not(tf.reduce_any(coordinate_violations, 1))), [-1])
return gather(boxlist, valid_indices), valid_indices
def _variance(self):
# We need to put the tf.where inside the outer tf.where to ensure we never
# hit a NaN in the gradient.
denom = tf.where(tf.greater(self.df, 2.),
self.df - 2.,
tf.ones_like(self.df))
# Abs(scale) superfluous.
var = (tf.ones(self.batch_shape_tensor(), dtype=self.dtype) *
tf.square(self.scale) * self.df / denom)
# When 1 < df <= 2, variance is infinite.
inf = np.array(np.inf, dtype=self.dtype.as_numpy_dtype())
result_where_defined = tf.where(
self.df > tf.fill(self.batch_shape_tensor(), 2.),
var,
tf.fill(self.batch_shape_tensor(), inf, name="inf"))
if self.allow_nan_stats:
nan = np.array(np.nan, dtype=self.dtype.as_numpy_dtype())
return tf.where(
tf.greater(
self.df,
tf.ones(self.batch_shape_tensor(), dtype=self.dtype)),
result_where_defined,
tf.fill(self.batch_shape_tensor(), nan, name="nan"))
else:
return control_flow_ops.with_dependencies(
[
tf.assert_less(
tf.ones([], dtype=self.dtype),
self.df,
message="variance not defined for components of df <= 1"),
],
result_where_defined)
def _compute_precision_recall(input_layer, labels, threshold,
per_example_weights):
"""Returns the numerator of both, the denominator of precision and recall."""
# To apply per_example_weights, we need to collapse each row to a scalar, but
# we really want the sum.
labels.get_shape().assert_is_compatible_with(input_layer.get_shape())
relevant = tf.to_float(tf.greater(labels, 0))
retrieved = tf.to_float(tf.greater(input_layer, threshold))
selected = relevant * retrieved
if per_example_weights:
per_example_weights = tf.convert_to_tensor(per_example_weights,
name='per_example_weights')
if selected.get_shape().dims:
per_example_weights.get_shape().assert_is_compatible_with(
[selected.get_shape().dims[0]])
else:
per_example_weights.get_shape().assert_is_compatible_with([None])
per_example_weights = tf.to_float(tf.greater(per_example_weights, 0))
selected = functions.reduce_batch_sum(selected) * per_example_weights
relevant = functions.reduce_batch_sum(relevant) * per_example_weights
retrieved = functions.reduce_batch_sum(retrieved) * per_example_weights
sum_relevant = tf.reduce_sum(relevant)
sum_retrieved = tf.reduce_sum(retrieved)
selected = tf.reduce_sum(selected)
return selected, sum_retrieved, sum_relevant
def sanitize(self, x, eps_delta, sigma=None,
option=ClipOption(None, None), tensor_name=None,
num_examples=None, add_noise=True):
"""Sanitize the given tensor.
This santize a given tensor by first applying l2 norm clipping and then
adding Gaussian noise. It calls the privacy accountant for updating the
privacy spending.
Args:
x: the tensor to sanitize.
eps_delta: a pair of eps, delta for (eps,delta)-DP. Use it to
compute sigma if sigma is None.
sigma: if sigma is not None, use sigma.
option: a ClipOption which, if supplied, used for
clipping and adding noise.
tensor_name: the name of the tensor.
num_examples: if None, use the number of "rows" of x.
add_noise: if True, then add noise, else just clip.
Returns:
a pair of sanitized tensor and the operation to accumulate privacy
spending.
"""
if sigma is None:
# pylint: disable=unpacking-non-sequence
eps, delta = eps_delta
with tf.control_dependencies(
[tf.Assert(tf.greater(eps, 0),
["eps needs to be greater than 0"]),
tf.Assert(tf.greater(delta, 0),
["delta needs to be greater than 0"])]):
# The following formula is taken from
# Dwork and Roth, The Algorithmic Foundations of Differential
# Privacy, Appendix A.
# http://www.cis.upenn.edu/~aaroth/Papers/privacybook.pdf
sigma = tf.sqrt(2.0 * tf.log(1.25 / delta)) / eps
l2norm_bound, clip = option
if l2norm_bound is None:
l2norm_bound, clip = self._default_option
if ((tensor_name is not None) and
(tensor_name in self._options)):
l2norm_bound, clip = self._options[tensor_name]
if clip:
x = utils.BatchClipByL2norm(x, l2norm_bound)
if add_noise:
if num_examples is None:
num_examples = tf.slice(tf.shape(x), [0], [1])
privacy_accum_op = self._accountant.accumulate_privacy_spending(
eps_delta, sigma, num_examples)
with tf.control_dependencies([privacy_accum_op]):
saned_x = utils.AddGaussianNoise(tf.reduce_sum(x, 0),
sigma * l2norm_bound)
else:
saned_x = tf.reduce_sum(x, 0)
return saned_x
def _get_valid_sample_fraction(labels, p=0):
"""return fraction of non-negative examples, the ignored examples have been marked as negative"""
num_valid = tf.reduce_sum(tf.cast(tf.greater_equal(labels, p), tf.float32))
num_example = tf.cast(tf.size(labels), tf.float32)
frac = tf.cond(tf.greater(num_example, 0), lambda:num_valid / num_example,
lambda: tf.cast(0, tf.float32))
frac_ = tf.cond(tf.greater(num_valid, 0), lambda:num_example / num_valid,
lambda: tf.cast(0, tf.float32))
return frac, frac_
def style_loss(CNN_structure, const_layers, var_layers, content_segs, style_segs, weight):
loss_styles = []
layer_count = float(len(const_layers))
layer_index = 0
_, content_seg_height, content_seg_width, _ = content_segs[0].get_shape().as_list()
_, style_seg_height, style_seg_width, _ = style_segs[0].get_shape().as_list()
for layer_name in CNN_structure:
layer_name = layer_name[layer_name.find("/") + 1:]
# downsampling segmentation
if "pool" in layer_name:
content_seg_width, content_seg_height = int(math.ceil(content_seg_width / 2)), int(math.ceil(content_seg_height / 2))
style_seg_width, style_seg_height = int(math.ceil(style_seg_width / 2)), int(math.ceil(style_seg_height / 2))
for i in xrange(len(content_segs)):
content_segs[i] = tf.image.resize_bilinear(content_segs[i], tf.constant((content_seg_height, content_seg_width)))
style_segs[i] = tf.image.resize_bilinear(style_segs[i], tf.constant((style_seg_height, style_seg_width)))
elif "conv" in layer_name:
for i in xrange(len(content_segs)):
# have some differences on border with torch
content_segs[i] = tf.nn.avg_pool(tf.pad(content_segs[i], [[0, 0], [1, 1], [1, 1], [0, 0]], "CONSTANT"), \
ksize=[1, 3, 3, 1], strides=[1, 1, 1, 1], padding='VALID')
style_segs[i] = tf.nn.avg_pool(tf.pad(style_segs[i], [[0, 0], [1, 1], [1, 1], [0, 0]], "CONSTANT"), \
ksize=[1, 3, 3, 1], strides=[1, 1, 1, 1], padding='VALID')
if layer_name == var_layers[layer_index].name[var_layers[layer_index].name.find("/") + 1:]:
print("Setting up style layer: <{}>".format(layer_name))
const_layer = const_layers[layer_index]
var_layer = var_layers[layer_index]
layer_index = layer_index + 1
layer_style_loss = 0.0
for content_seg, style_seg in zip(content_segs, style_segs):
gram_matrix_const = gram_matrix(tf.multiply(const_layer, style_seg))
style_mask_mean = tf.reduce_mean(style_seg)
gram_matrix_const = tf.cond(tf.greater(style_mask_mean, 0.),
lambda: gram_matrix_const / (tf.to_float(tf.size(const_layer)) * style_mask_mean),
lambda: gram_matrix_const
)
gram_matrix_var = gram_matrix(tf.multiply(var_layer, content_seg))
content_mask_mean = tf.reduce_mean(content_seg)
gram_matrix_var = tf.cond(tf.greater(content_mask_mean, 0.),
lambda: gram_matrix_var / (tf.to_float(tf.size(var_layer)) * content_mask_mean),
lambda: gram_matrix_var
)
diff_style_sum = tf.reduce_mean(tf.squared_difference(gram_matrix_const, gram_matrix_var)) * content_mask_mean
layer_style_loss += diff_style_sum
loss_styles.append(layer_style_loss * weight)
return loss_styles
def get_position_cross_clf_label(positions, seq_length, ans_avg_len):
start_labels = tf.reshape(positions[:, 0], [-1]) # positions shape: [batch_size, 2] => [batch_size]
end_labels = tf.reshape(positions[:, 1], [-1])
ans_len = end_labels - start_labels +1 # [batch_size] # 超过ans_avg_len则为avg_len
mask = tf.cast(tf.greater(ans_len, ans_avg_len), tf.int32) * (
tf.zeros_like(ans_len, dtype=tf.int32) + ans_avg_len)
ans_len = ans_len * (1 - tf.cast(tf.greater(ans_len, ans_avg_len), tf.int32)) + mask
return start_labels * ans_avg_len + ans_len - 1
def _match_when_rows_are_non_empty():
"""Performs matching when the rows of similarity matrix are non empty.
Returns:
matches: int32 tensor indicating the row each column matches to.
"""
# Matches for each column
matches = tf.argmax(similarity_matrix, 0, output_type=tf.int32)
# Deal with matched and unmatched threshold
if self._matched_threshold is not None:
# Get logical indices of ignored and unmatched columns as tf.int64
matched_vals = tf.reduce_max(similarity_matrix, 0)
below_unmatched_threshold = tf.greater(self._unmatched_threshold,
matched_vals)
between_thresholds = tf.logical_and(
tf.greater_equal(matched_vals, self._unmatched_threshold),
tf.greater(self._matched_threshold, matched_vals))
if self._negatives_lower_than_unmatched:
matches = self._set_values_using_indicator(matches,
below_unmatched_threshold,
-1)
matches = self._set_values_using_indicator(matches,
between_thresholds,
-2)
else:
matches = self._set_values_using_indicator(matches,
below_unmatched_threshold,
-2)
matches = self._set_values_using_indicator(matches,
between_thresholds,
-1)
if self._force_match_for_each_row:
similarity_matrix_shape = shape_utils.combined_static_and_dynamic_shape(
similarity_matrix)
force_match_column_ids = tf.argmax(similarity_matrix, 1,
output_type=tf.int32)
force_match_column_indicators = (
tf.one_hot(
force_match_column_ids, depth=similarity_matrix_shape[1]) *
tf.cast(tf.expand_dims(valid_rows, axis=-1), dtype=tf.float32))
force_match_row_ids = tf.argmax(force_match_column_indicators, 0,
output_type=tf.int32)
force_match_column_mask = tf.cast(
tf.reduce_max(force_match_column_indicators, 0), tf.bool)
final_matches = tf.where(force_match_column_mask,
force_match_row_ids, matches)
return final_matches
else:
return matches
def _compute_alpha(x):
"""
Computing the scale parameter.
"""
threshold = _compute_threshold(x)
alpha1_temp1 = tf.where(tf.greater(x, threshold), x, tf.zeros_like(x, tf.float32))
alpha1_temp2 = tf.where(tf.less(x, -threshold), x, tf.zeros_like(x, tf.float32))
alpha_array = tf.add(alpha1_temp1, alpha1_temp2, name=None)
alpha_array_abs = tf.abs(alpha_array)
alpha_array_abs1 = tf.where(tf.greater(alpha_array_abs, 0), tf.ones_like(alpha_array_abs, tf.float32), tf.zeros_like(alpha_array_abs, tf.float32))
alpha_sum = tf.reduce_sum(alpha_array_abs)
n = tf.reduce_sum(alpha_array_abs1)
alpha = tf.div(alpha_sum, n)
return alpha
def _match_when_rows_are_non_empty():
"""Performs matching when the rows of similarity matrix are non empty.
Returns:
matches: int32 tensor indicating the row each column matches to.
"""
# Matches for each column
matches = tf.argmax(similarity_matrix, 0)
# Deal with matched and unmatched threshold
if self._matched_threshold is not None:
# Get logical indices of ignored and unmatched columns as tf.int64
matched_vals = tf.reduce_max(similarity_matrix, 0)
below_unmatched_threshold = tf.greater(self._unmatched_threshold,
matched_vals)
between_thresholds = tf.logical_and(
tf.greater_equal(matched_vals, self._unmatched_threshold),
tf.greater(self._matched_threshold, matched_vals))
if self._negatives_lower_than_unmatched:
matches = self._set_values_using_indicator(matches,
below_unmatched_threshold,
-1)
matches = self._set_values_using_indicator(matches,
between_thresholds,
-2)
else:
matches = self._set_values_using_indicator(matches,
below_unmatched_threshold,
-2)
matches = self._set_values_using_indicator(matches,
between_thresholds,
-1)
if self._force_match_for_each_row:
forced_matches_ids = tf.cast(tf.argmax(similarity_matrix, 1), tf.int32)
# Set matches[forced_matches_ids] = [0, ..., R], R is number of rows.
row_range = tf.range(tf.shape(similarity_matrix)[0])
col_range = tf.range(tf.shape(similarity_matrix)[1])
forced_matches_values = tf.cast(row_range, matches.dtype)
keep_matches_ids, _ = tf.setdiff1d(col_range, forced_matches_ids)
keep_matches_values = tf.gather(matches, keep_matches_ids)
matches = tf.dynamic_stitch(
[forced_matches_ids,
keep_matches_ids], [forced_matches_values, keep_matches_values])
return tf.cast(matches, tf.int32)
def to_normalized_coordinates(boxlist, height, width,
check_range=True, scope=None):
"""Converts absolute box coordinates to normalized coordinates in [0, 1].
Usually one uses the dynamic shape of the image or conv-layer tensor:
boxlist = box_list_ops.to_normalized_coordinates(boxlist,
tf.shape(images)[1],
tf.shape(images)[2]),
This function raises an assertion failed error at graph execution time when
the maximum coordinate is smaller than 1.01 (which means that coordinates are
already normalized). The value 1.01 is to deal with small rounding errors.
Args:
boxlist: BoxList with coordinates in terms of pixel-locations.
height: Maximum value for height of absolute box coordinates.
width: Maximum value for width of absolute box coordinates.
check_range: If True, checks if the coordinates are normalized or not.
scope: name scope.
Returns:
boxlist with normalized coordinates in [0, 1].
"""
with tf.name_scope(scope, 'ToNormalizedCoordinates'):
height = tf.cast(height, tf.float32)
width = tf.cast(width, tf.float32)
if check_range:
max_val = tf.reduce_max(boxlist.get())
max_assert = tf.Assert(tf.greater(max_val, 1.01),
['max value is lower than 1.01: ', max_val])
with tf.control_dependencies([max_assert]):
width = tf.identity(width)
return scale(boxlist, 1 / height, 1 / width)
def __imagenet_data_process_function(self, x, y):
with tf.name_scope("imagenet_data_aug") as scope:
#random scale
#apparently, this works better than what we have:
#https://github.com/facebook/fb.resnet.torch
#but let's use the 'original' formulation for now
#randomly sample a size in specified range
random_size = tf.squeeze(tf.random_uniform((1, 1), 256, 480, dtype=tf.int32, name="random_scale_size"))
#rescale smaller size with this factor
tf.cond(tf.greater(tf.shape(x)[0], tf.shape(x)[1]),
lambda: tf.image.resize_images(x, [tf.shape(x)[0] * (tf.shape(x)[1] / random_size), random_size]),
lambda: tf.image.resize_images(x, [random_size, tf.shape(x)[1] * (tf.shape(x)[0] / random_size)]))
x = tf.image.resize_images(x, [224, 224])
#random flip
x = tf.image.flip_left_right(x)
#random crop
x = tf.random_crop(x, [224, 224, 3])
#colour augmentation
#this is a little more involved than I first thought
#lets pick the inception colour distortion
#https://github.com/tensorflow/models/blob/master/inception/inception/image_processing.py
x = tf.image.random_brightness(x, max_delta=32. / 255.)
x = tf.image.random_saturation(x, lower=0.5, upper=1.5)
x = tf.image.random_hue(x, max_delta=0.2)
x = tf.image.random_contrast(x, lower=0.5, upper=1.5)
x = tf.clip_by_value(x, 0.0, 1.0)
#normalisation
x = tf.image.per_image_standardization(x)
return [x, y]
def accumulate_privacy_spending(self, eps_delta, unused_sigma,
num_examples):
"""Accumulate the privacy spending.
Currently only support approximate privacy. Here we assume we use Gaussian
noise on randomly sampled batch so we get better composition: 1. the per
batch privacy is computed using privacy amplication via sampling bound;
2. the composition is done using the composition with Gaussian noise.
TODO(liqzhang) Add a link to a document that describes the bounds used.
Args:
eps_delta: EpsDelta pair which can be tensors.
unused_sigma: the noise sigma. Unused for this accountant.
num_examples: the number of examples involved.
Returns:
a TensorFlow operation for updating the privacy spending.
"""
eps, delta = eps_delta
with tf.control_dependencies(
[tf.Assert(tf.greater(delta, 0),
["delta needs to be greater than 0"])]):
amortize_ratio = (tf.cast(num_examples, tf.float32) * 1.0 /
self._total_examples)
# Use privacy amplification via sampling bound.
# See Lemma 2.2 in http://arxiv.org/pdf/1405.7085v2.pdf
# TODO(liqzhang) Add a link to a document with formal statement
# and proof.
amortize_eps = tf.reshape(tf.log(1.0 + amortize_ratio * (
tf.exp(eps) - 1.0)), [1])
amortize_delta = tf.reshape(amortize_ratio * delta, [1])
return tf.group(*[tf.assign_add(self._eps_squared_sum,
tf.square(amortize_eps)),
tf.assign_add(self._delta_sum, amortize_delta)])
def do_report():
r = sess.run([best,
correct,
tf.greater(y[:, 0], 0),
y_[:, 0],
digits_loss,
presence_loss,
cross_entropy],
feed_dict={x: test_xs, y_: test_ys})
num_correct = numpy.sum(
numpy.logical_or(
numpy.all(r[0] == r[1], axis=1),
numpy.logical_and(r[2] < 0.5,
r[3] < 0.5)))
r_short = (r[0][:190], r[1][:190], r[2][:190], r[3][:190])
for b, c, pb, pc in zip(*r_short):
print "{} {} <-> {} {}".format(vec_to_plate(c), pc,
vec_to_plate(b), float(pb))
num_p_correct = numpy.sum(r[2] == r[3])
print ("B{:3d} {:2.02f}% {:02.02f}% loss: {} "
"(digits: {}, presence: {}) |{}|").format(
batch_idx,
100. * num_correct / (len(r[0])),
100. * num_p_correct / len(r[2]),
r[6],
r[4],
r[5],
"".join("X "[numpy.array_equal(b, c) or (not pb and not pc)]
for b, c, pb, pc in zip(*r_short)))
def loss(self, logits, labels, regularization):
"""Adds to the inference model the layers required to generate loss."""
with tf.name_scope('loss'):
with tf.name_scope('var_loss'):
labels = tf.cast(labels, tf.float32)
shape = labels.get_shape()
same_class = tf.boolean_mask(logits, tf.equal(labels, tf.ones(shape)))
diff_class = tf.boolean_mask(logits, tf.not_equal(labels, tf.ones(shape)))
same_mean, same_var = tf.nn.moments(same_class, [0])
diff_mean, diff_var = tf.nn.moments(diff_class, [0])
var_loss = same_var + diff_var
with tf.name_scope('mean_loss'):
mean_loss = self.lamda * tf.where(tf.greater(self.mu - (same_mean - diff_mean), 0),
self.mu - (same_mean - diff_mean), 0)
with tf.name_scope('regularization'):
regularization *= tf.add_n(self.regularizers)
loss = var_loss + mean_loss + regularization
# Summaries for TensorBoard.
tf.summary.scalar('loss/total', loss)
with tf.name_scope('averages'):
averages = tf.train.ExponentialMovingAverage(0.9)
op_averages = averages.apply([var_loss, mean_loss, regularization, loss])
tf.summary.scalar('loss/avg/var_loss', averages.average(var_loss))
tf.summary.scalar('loss/avg/mean_loss', averages.average(mean_loss))
tf.summary.scalar('loss/avg/regularization', averages.average(regularization))
tf.summary.scalar('loss/avg/total', averages.average(loss))
with tf.control_dependencies([op_averages]):
loss_average = tf.identity(averages.average(loss), name='control')
return loss, loss_average
def unwrap(p, discont=np.pi, axis=-1):
"""Unwrap a cyclical phase tensor.
Args:
p: Phase tensor.
discont: Float, size of the cyclic discontinuity.
axis: Axis of which to unwrap.
Returns:
unwrapped: Unwrapped tensor of same size as input.
"""
dd = diff(p, axis=axis)
ddmod = tf.mod(dd + np.pi, 2.0 * np.pi) - np.pi
idx = tf.logical_and(tf.equal(ddmod, -np.pi), tf.greater(dd, 0))
ddmod = tf.where(idx, tf.ones_like(ddmod) * np.pi, ddmod)
ph_correct = ddmod - dd
idx = tf.less(tf.abs(dd), discont)
ddmod = tf.where(idx, tf.zeros_like(ddmod), dd)
ph_cumsum = tf.cumsum(ph_correct, axis=axis)
shape = p.get_shape().as_list()
shape[axis] = 1
ph_cumsum = tf.concat([tf.zeros(shape, dtype=p.dtype), ph_cumsum], axis=axis)
unwrapped = p + ph_cumsum
return unwrapped
def _decode_png_instance_masks(self, keys_to_tensors):
"""Decode PNG instance segmentation masks and stack into dense tensor.
The instance segmentation masks are reshaped to [num_instances, height,
width].
Args:
keys_to_tensors: a dictionary from keys to tensors.
Returns:
A 3-D float tensor of shape [num_instances, height, width] with values
in {0, 1}.
"""
def decode_png_mask(image_buffer):
image = tf.squeeze(
tf.image.decode_image(image_buffer, channels=1), axis=2)
image.set_shape([None, None])
image = tf.to_float(tf.greater(image, 0))
return image
png_masks = keys_to_tensors['image/object/mask']
height = keys_to_tensors['image/height']
width = keys_to_tensors['image/width']
if isinstance(png_masks, tf.SparseTensor):
png_masks = tf.sparse_tensor_to_dense(png_masks, default_value='')
return tf.cond(
tf.greater(tf.size(png_masks), 0),
lambda: tf.map_fn(decode_png_mask, png_masks, dtype=tf.float32),
lambda: tf.zeros(tf.to_int32(tf.stack([0, height, width]))))
def loss(self, logits, labels, regularization):
"""Adds to the inference model the layers required to generate loss."""
with tf.name_scope('loss'):
with tf.name_scope('hinge_loss'):
labels = tf.cast(labels, tf.float32)
zeros = tf.zeros(labels.get_shape())
output = tf.ones(labels.get_shape()) - tf.multiply(labels, logits)
hinge_loss = tf.where(tf.greater(output, zeros), output, zeros)
hinge_loss = tf.reduce_mean(hinge_loss)
with tf.name_scope('regularization'):
regularization *= tf.add_n(self.regularizers)
loss = hinge_loss + regularization
# Summaries for TensorBoard.
tf.summary.scalar('loss/hinge_loss', hinge_loss)
tf.summary.scalar('loss/regularization', regularization)
tf.summary.scalar('loss/total', loss)
with tf.name_scope('averages'):
averages = tf.train.ExponentialMovingAverage(0.9)
op_averages = averages.apply([hinge_loss, regularization, loss])
tf.summary.scalar('loss/avg/hinge_loss', averages.average(hinge_loss))
tf.summary.scalar('loss/avg/regularization', averages.average(regularization))
tf.summary.scalar('loss/avg/total', averages.average(loss))
with tf.control_dependencies([op_averages]):
loss_average = tf.identity(averages.average(loss), name='control')
return loss, loss_average
def testProbabilitiesCanBeChanged(self):
# Set up graph.
tf.set_random_seed(1234)
lbl1 = 0
lbl2 = 3
# This cond allows the necessary class queues to be populated.
label = tf.cond(tf.greater(0.5, tf.random_uniform([])), lambda: tf.constant(lbl1), lambda: tf.constant(lbl2))
val = [np.array([1, 4]) * label]
probs = tf.placeholder(tf.float32, shape=[5])
batch_size = 2
data_batch, labels = tf.contrib.training.stratified_sample_unknown_dist(val, label, probs, batch_size)
with self.test_session() as sess:
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
for _ in range(5):
[data], lbls = sess.run([data_batch, labels], feed_dict={probs: [1, 0, 0, 0, 0]})
for data_example in data:
self.assertListEqual([0, 0], list(data_example))
self.assertListEqual([0, 0], list(lbls))
# Now change distribution and expect different output.
for _ in range(5):
[data], lbls = sess.run([data_batch, labels], feed_dict={probs: [0, 0, 0, 1, 0]})
for data_example in data:
self.assertListEqual([3, 12], list(data_example))
self.assertListEqual([3, 3], list(lbls))
coord.request_stop()
coord.join(threads)
def _smallest_size_at_least(height, width, smallest_side):
"""Computes new shape with the smallest side equal to `smallest_side`.
Computes new shape with the smallest side equal to `smallest_side` while
preserving the original aspect ratio.
Args:
height: an int32 scalar tensor indicating the current height.
width: an int32 scalar tensor indicating the current width.
smallest_side: A python integer or scalar `Tensor` indicating the size of
the smallest side after resize.
Returns:
new_height: an int32 scalar tensor indicating the new height.
new_width: and int32 scalar tensor indicating the new width.
"""
smallest_side = tf.convert_to_tensor(smallest_side, dtype=tf.int32)
height = tf.to_float(height)
width = tf.to_float(width)
smallest_side = tf.to_float(smallest_side)
scale = tf.cond(tf.greater(height, width),
lambda: smallest_side / width,
lambda: smallest_side / height)
new_height = tf.to_int32(height * scale)
new_width = tf.to_int32(width * scale)
return new_height, new_width
def beta_schedule(schedule, global_step, final_beta, decay_start, decay_end):
"""Get KL multiplier (beta) based on the schedule."""
if decay_start > decay_end:
raise ValueError("decay_end is smaller than decay_end.")
# Since some of the TF schedules do not support incrementing a value,
# in all of the schedules, we anneal the beta from final_beta to zero
# and then reverse it at the bottom.
if schedule == "constant":
decayed_value = 0.0
elif schedule == "linear":
decayed_value = tf.train.polynomial_decay(
learning_rate=final_beta,
global_step=global_step - decay_start,
decay_steps=decay_end - decay_start,
end_learning_rate=0.0)
elif schedule == "noisy_linear_cosine_decay":
decayed_value = tf.train.noisy_linear_cosine_decay(
learning_rate=final_beta,
global_step=global_step - decay_start,
decay_steps=decay_end - decay_start)
# TODO(mechcoder): Add log_annealing schedule.
else:
raise ValueError("Unknown beta schedule.")
increased_value = final_beta - decayed_value
increased_value = tf.maximum(0.0, increased_value)
beta = tf.case(
pred_fn_pairs={
tf.less(global_step, decay_start): lambda: 0.0,
tf.greater(global_step, decay_end): lambda: final_beta},
default=lambda: increased_value)
return beta
def _get_num_pos_neg_samples(self, sorted_indices_tensor, sample_size):
"""Counts the number of positives and negatives numbers to be sampled.
Args:
sorted_indices_tensor: A sorted int32 tensor of shape [N] which contains
the signed indices of the examples where the sign is based on the label
value. The examples that cannot be sampled are set to 0. It samples
atmost sample_size*positive_fraction positive examples and remaining
from negative examples.
sample_size: Size of subsamples.
Returns:
A tuple containing the number of positive and negative labels in the
subsample.
"""
input_length = tf.shape(sorted_indices_tensor)[0]
valid_positive_index = tf.greater(sorted_indices_tensor,
tf.zeros(input_length, tf.int32))
num_sampled_pos = tf.reduce_sum(tf.cast(valid_positive_index, tf.int32))
max_num_positive_samples = tf.constant(
int(sample_size * self._positive_fraction), tf.int32)
num_positive_samples = tf.minimum(max_num_positive_samples, num_sampled_pos)
num_negative_samples = tf.constant(sample_size,
tf.int32) - num_positive_samples
return num_positive_samples, num_negative_samples
def process_single_frame(prev_outputs, inputs):
"""Process a single frame of the video."""
cur_image, input_reward, action = inputs
time_step, prev_image, prev_reward, frame_buf, lstm_states = prev_outputs
# sample from softmax (by argmax). this is noop for non-softmax loss.
prev_image = self.get_sampled_frame(prev_image)
generated_items = [prev_image]
groundtruth_items = [cur_image]
done_warm_start = tf.greater(time_step, context_frames - 1)
input_image, = self.get_scheduled_sample_inputs(
done_warm_start, groundtruth_items, generated_items, ss_func)
# Prediction
pred_image, lstm_states, _ = self.construct_predictive_tower(
input_image, None, action, lstm_states, latent)
if self.hparams.reward_prediction:
reward_input_image = self.get_sampled_frame(pred_image)
if self.hparams.reward_prediction_stop_gradient:
reward_input_image = tf.stop_gradient(reward_input_image)
with tf.control_dependencies([time_step]):
frame_buf = [reward_input_image] + frame_buf[:-1]
pred_reward = self.reward_prediction(frame_buf, None, action, latent)
pred_reward = common_video.decode_to_shape(
pred_reward, common_layers.shape_list(input_reward), "reward_dec")
else:
pred_reward = prev_reward
time_step += 1
outputs = (time_step, pred_image, pred_reward, frame_buf, lstm_states)
return outputs
def binary_accuracy_op(predictions, targets):
""" binary_accuracy_op.
An op that calculates mean accuracy, assuming predictions are logits, and
targets are binary encoded (and represented as int32).
Examples:
```python
input_data = placeholder(shape=[None, 784])
y_pred = my_network(input_data) # Apply some ops
y_true = placeholder(shape=[None, 10]) # Labels
acc_op = binary_accuracy_op(y_pred, y_true)
# Calculate accuracy by feeding data X and labels Y
binary_accuracy = sess.run(acc_op, feed_dict={input_data: X, y_true: Y})
```
Arguments:
predictions: `Tensor` of `float` type.
targets: `Tensor` of `float` type.
Returns:
`Float`. The mean accuracy.
"""
if not isinstance(targets, tf.Tensor):
raise ValueError("mean_accuracy 'input' argument only accepts type "
"Tensor, '" + str(type(input)) + "' given.")
with tf.name_scope('BinaryAccuracy'):
predictions = tf.cast(tf.greater(predictions, 0), tf.float32)
correct_pred = tf.equal(predictions, tf.cast(targets, tf.float32))
acc = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
return acc
def custom_rnn_autodecoder(decoder_inputs, initial_input, initial_state, cell, scope=None):
# customized rnn_decoder for the task of dealing with end of character
with tf.variable_scope(scope or "rnn_decoder"):
states = [initial_state]
outputs = []
prev = None
for i in xrange(len(decoder_inputs)):
inp = decoder_inputs[i]
if i > 0:
tf.get_variable_scope().reuse_variables()
output, new_state = cell(inp, states[-1])
num_batches = self.args.batch_size # new_state.get_shape()[0].value
num_state = new_state.get_shape()[1].value
# if the input has an end-of-character signal, have to zero out the state
#to do: test this code.
eoc_detection = inp[:,3]
eoc_detection = tf.reshape(eoc_detection, [num_batches, 1])
eoc_detection_state = tfrepeat(eoc_detection, num_state)
eoc_detection_state = tf.greater(eoc_detection_state, tf.zeros_like(eoc_detection_state, dtype=tf.float32))
new_state = tf.select(eoc_detection_state, initial_state, new_state)
outputs.append(output)
states.append(new_state)
return outputs, states
def logistic_loss(prediction, label):
""" Logistic loss function averaged over pixels in the breast area.
Pixels in the background are ignored.
Args:
prediction: A 2D tensor of floats. The predicted heatmap of logits.
label: A 2D tensor of integers. Possible labels are 0 (background), 127
(breast tissue) and 255 (breast mass).
Returns:
A float. The loss.
"""
with tf.name_scope('logistic_loss'):
# Generate binary masks.
mass = tf.to_float(tf.equal(label, 255))
breast_area = tf.to_float(tf.greater(label, 0))
# Compute loss per pixel
pixel_loss = tf.nn.sigmoid_cross_entropy_with_logits(prediction, mass)
# Weight the errors (1 for pixels in breast area, zero otherwise)
weighted_loss = tf.mul(pixel_loss, breast_area)
# Average over pixels in the breast area
loss = tf.reduce_sum(weighted_loss)/tf.reduce_sum(breast_area)
return loss
def run_inference_for_single_image(image, graph):
with graph.as_default():
# with tf.Session() as sess:
with sess.as_default():
# Get handles to input and output tensors
ops = tf.get_default_graph().get_operations()
all_tensor_names = {
output.name
for op in ops for output in op.outputs
}
tensor_dict = {}
for key in [
'num_detections', 'detection_boxes', 'detection_scores',
'detection_classes', 'detection_masks'
]:
tensor_name = key + ':0'
if tensor_name in all_tensor_names:
tensor_dict[key] = tf.get_default_graph(
).get_tensor_by_name(tensor_name)
if 'detection_masks' in tensor_dict:
# The following processing is only for single image
detection_boxes = tf.squeeze(tensor_dict['detection_boxes'],
[0])
detection_masks = tf.squeeze(tensor_dict['detection_masks'],
[0])
# Reframe is required to translate mask from box coordinates to image coordinates and fit the image size.
real_num_detection = tf.cast(tensor_dict['num_detections'][0],
tf.int32)
detection_boxes = tf.slice(detection_boxes, [0, 0],
[real_num_detection, -1])
detection_masks = tf.slice(detection_masks, [0, 0, 0],
[real_num_detection, -1, -1])
detection_masks_reframed = utils_ops.reframe_box_masks_to_image_masks(
detection_masks, detection_boxes, image.shape[0],
image.shape[1])
detection_masks_reframed = tf.cast(
tf.greater(detection_masks_reframed, 0.5), tf.uint8)
# Follow the convention by adding back the batch dimension
tensor_dict['detection_masks'] = tf.expand_dims(
detection_masks_reframed, 0)
image_tensor = tf.get_default_graph().get_tensor_by_name(
'image_tensor:0')
# Run inference
output_dict = sess.run(
tensor_dict,
feed_dict={image_tensor: np.expand_dims(image, 0)})
# all outputs are float32 numpy arrays, so convert types as appropriate
output_dict['num_detections'] = int(
output_dict['num_detections'][0])
output_dict['detection_classes'] = output_dict[
'detection_classes'][0].astype(np.uint8)
output_dict['detection_boxes'] = output_dict['detection_boxes'][0]
output_dict['detection_scores'] = output_dict['detection_scores'][
0]
# print(output_dict['num_detections'])
# print(output_dict['detection_classes'])
#print(output_dict['detection_scores'])
if 'detection_masks' in output_dict:
output_dict['detection_masks'] = output_dict[
'detection_masks'][0]
return output_dict
def __init__(self, *, policy, ob_space, ac_space, nbatch_act, nbatch_train,
nsteps, ent_coef, vf_coef, max_grad_norm, microbatch_size=None):
self.sess = sess = get_session()
with tf.variable_scope('ppo2_model', reuse=tf.AUTO_REUSE):
# CREATE OUR TWO MODELS
# act_model that is used for sampling
act_model = policy(nbatch_act, 1, sess)
# Train model for training
if microbatch_size is None:
train_model = policy(nbatch_train, nsteps, sess)
else:
train_model = policy(microbatch_size, nsteps, sess)
# CREATE THE PLACEHOLDERS
self.A = A = train_model.pdtype.sample_placeholder([None])
self.ADV = ADV = tf.placeholder(tf.float32, [None])
self.R = R = tf.placeholder(tf.float32, [None])
# Keep track of old actor
self.OLDNEGLOGPAC = OLDNEGLOGPAC = tf.placeholder(tf.float32, [None])
# Keep track of old critic
self.OLDVPRED = OLDVPRED = tf.placeholder(tf.float32, [None])
self.LR = LR = tf.placeholder(tf.float32, [])
# Cliprange
self.CLIPRANGE = CLIPRANGE = tf.placeholder(tf.float32, [])
neglogpac = train_model.pd.neglogp(A)
# Calculate the entropy
# Entropy is used to improve exploration by limiting the premature convergence to suboptimal policy.
entropy = tf.reduce_mean(train_model.pd.entropy())
# CALCULATE THE LOSS
# Total loss = Policy gradient loss - entropy * entropy coefficient + Value coefficient * value loss
# Clip the value to reduce variability during Critic training
# Get the predicted value
vpred = train_model.vf
vpredclipped = OLDVPRED + tf.clip_by_value(train_model.vf - OLDVPRED, - CLIPRANGE, CLIPRANGE)
# Unclipped value
vf_losses1 = tf.square(vpred - R)
# Clipped value
vf_losses2 = tf.square(vpredclipped - R)
vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
# Calculate ratio (pi current policy / pi old policy)
ratio = tf.exp(OLDNEGLOGPAC - neglogpac)
# Defining Loss = - J is equivalent to max J
pg_losses = -ADV * ratio
pg_losses2 = -ADV * tf.clip_by_value(ratio, 1.0 - CLIPRANGE, 1.0 + CLIPRANGE)
# Final PG loss
pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - OLDNEGLOGPAC))
clipfrac = tf.reduce_mean(tf.to_float(tf.greater(tf.abs(ratio - 1.0), CLIPRANGE)))
# Total loss
loss = pg_loss - entropy * ent_coef + vf_loss * vf_coef
# UPDATE THE PARAMETERS USING LOSS
# 1. Get the model parameters
params = tf.trainable_variables('ppo2_model')
# 2. Build our trainer
if MPI is not None:
self.trainer = MpiAdamOptimizer(MPI.COMM_WORLD, learning_rate=LR, epsilon=1e-5)
else:
self.trainer = tf.train.AdamOptimizer(learning_rate=LR, epsilon=1e-5)
# 3. Calculate the gradients
grads_and_var = self.trainer.compute_gradients(loss, params)
grads, var = zip(*grads_and_var)
if max_grad_norm is not None:
# Clip the gradients (normalize)
grads, _grad_norm = tf.clip_by_global_norm(grads, max_grad_norm)
grads_and_var = list(zip(grads, var))
# zip aggregate each gradient with parameters associated
# For instance zip(ABCD, xyza) => Ax, By, Cz, Da
self.grads = grads
self.var = var
self._train_op = self.trainer.apply_gradients(grads_and_var)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
self.stats_list = [pg_loss, vf_loss, entropy, approxkl, clipfrac]
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.value = act_model.value
self.initial_state = act_model.initial_state
self.cal_neglogp = act_model.cal_neglogp
self.save = functools.partial(save_variables, sess=sess)
self.load = functools.partial(load_variables, sess=sess)
initialize()
global_variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="")
if MPI is not None:
sync_from_root(sess, global_variables) #pylint: disable=E1101
batch_size = 8
# 2个输入结点
x = tf.placeholder(tf.float32, shape=(None, 2), name='x-input')
# 回归问题只有1个输出结点
y_ = tf.placeholder(tf.float32, shape=(None, 1), name='y-input')
# 定义一个单层的神经网络前向传播过程，只是简单加权和
w1 = tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)
# 定义预测多了和预测少了的成本
loss_less = 1
loss_more = 10
loss = tf.reduce_sum(
tf.select(tf.greater(y, y_), loss_more*(y-y_), loss_less*(y_-y)))
train_step = tf.train.AdamOptimizer(0.001).minimize(loss)
# 定义损失函数为均方误差
loss_2 = tf.reduce_mean(tf.square(y_ - y))
train_step_2 = tf.train.AdamOptimizer(0.001).minimize(loss_2)
# 通过随机数生成一个模拟数据集
rdm = RandomState(1)
dataset_size = 128
X = rdm.rand(dataset_size, 2)
# 设置回归的正确值为两个输入加上一个随机量
Y = [[x1 + x2 + rdm.rand()/10.0-0.05] for (x1, x2) in X]
# 训练神经网络
with tf.Session() as sess:
def loop_step(batch_index, ts, stop_decoder, states, alphas, cand_seqs,
cand_scores, completed_scores, completed_scores_scaled,
completed_seqs, completed_lens):
"""
Args:
ts (int): time step
stop_decoder (bool): stop decoding
ys (?): [beam_size]
states (float): [beam_size, state_size]
alphas (float): [beam_size, alpha_size]
cand_scores: [beam_size], sequence score
cand_seqs: [beam_size, ts], ts increases over time
Returns:
logits shape: [beam_size, output_dim]
state: [beam_size, state_size]
alpha: [beam_size, alpha_size]
"""
# 1. get score from one step decoder
# logits = tf.one_hot(ts, depth=num_symbols, off_value=0.0, dtype=tf.float32)
if DEBUG: ts = tf.Print(ts, [ts], message='ts: ')
ys = cand_seqs[:, ts]
if DEBUG: ys = tf.Print(ys, [ys], message='Y(t-1): ')
logits, states, alphas = self.step(ys, states, alphas, batch_index)
if DEBUG: logits = tf.Print(logits, [logits], message='logits: ')
Z = tf.reduce_logsumexp(logits, 1, keep_dims=True)
if DEBUG: Z = tf.Print(Z, [Z], message='Z: ')
logprobs = tf.subtract(logits, Z) # [beam_size, num_symbols]
new_scores = tf.add(logprobs,
tf.expand_dims(cand_scores,
1)) # [beam_size, num_symbols]
if DEBUG:
new_scores = tf.Print(new_scores, [new_scores],
message='new_scores: ')
num_unstop_symbols = tf.shape(new_scores)[1] - 1
new_uncompleted_scores, new_completed_scores = tf.split(
new_scores, [num_unstop_symbols, 1], 1)
if DEBUG:
new_uncompleted_scores = tf.Print(
new_uncompleted_scores, [new_uncompleted_scores],
message='new_uncompleted_scores: ')
# 2. Update completed seqs --------------------------------------
# 2.1 update scores
new_completed_scores = tf.squeeze(new_completed_scores,
-1) # [beam_size]
all_completed_scores = tf.concat(
[completed_scores, new_completed_scores], 0) # [2*beam_size]
# 2.2 choose top K from scaled_scores
new_completed_scores_scaled = tf.div(new_completed_scores,
tf.to_float(ts + 1))
all_scores_scaled = tf.concat(
[completed_scores_scaled, new_completed_scores_scaled], 0)
completed_scores_scaled, indices = tf.nn.top_k(all_scores_scaled,
k=beam_size,
sorted=False)
if DEBUG:
indices = tf.Print(indices, [indices],
message='top K completed indices: ')
# 2.2 update len
new_completed_lens = tf.fill([beam_size], tf.add(ts,
1)) # [beam_size]
all_lens = tf.concat([completed_lens, new_completed_lens],
0) # [2*beam_size]
completed_lens = tf.gather(all_lens,
indices,
validate_indices=True,
axis=0) # [beam_size]
if DEBUG:
completed_lens = tf.Print(completed_lens, [completed_lens],
message='completed lens',
summarize=5)
# 2.3 update seqs
all_completed = tf.concat([completed_seqs, cand_seqs], 0)
completed_seqs = tf.gather(all_completed,
indices,
validate_indices=True,
axis=0) # [beam_size, ts]
if DEBUG:
completed_seqs = tf.Print(completed_seqs, [completed_seqs],
message='completed seqs: ',
summarize=MAX_STEPS + 2)
# 2.4 stop decoding loop
max_uncompleted = tf.reduce_max(new_uncompleted_scores)
completed_scores = tf.gather(all_completed_scores,
indices,
validate_indices=True,
axis=0)
min_completed = tf.reduce_min(completed_scores)
stop_decoder = tf.greater(min_completed, max_uncompleted)
# 2. Update completed seqs --------------------------------------
# 3. Update uncompleted sequences --------------------------------
# new_uncompleted_scores: [beam_size, num_symbols-1]
# top_k: [beam_size]. indices of top k scores
def f0():
return new_uncompleted_scores[0, :]
def f1():
return new_uncompleted_scores
un_scores = tf.cond(tf.equal(ts, 0), f0, f1)
new_flat = tf.squeeze(tf.reshape(
un_scores, [-1, 1])) # [beam_size*num_unstop_symbols]
# get top K symbols
cand_scores, flat_indices = tf.nn.top_k(new_flat,
k=beam_size,
sorted=False)
cand_parents = tf.div(flat_indices, num_unstop_symbols)
_ys = tf.mod(flat_indices,
num_unstop_symbols) # [beam_size], y(t) for next step
A = tf.gather(cand_seqs[:, 0:ts + 1],
cand_parents) #[beam_size, ts+1]
B = tf.expand_dims(_ys, -1) # [beam_size, 1]
C = tf.fill([beam_size, MAX_STEPS + 2 - ts - 2], stop_symbol)
cand_seqs = tf.concat([A, B, C], 1) # [beam_size, MAX_STEPS]
if DEBUG:
cand_seqs = tf.Print(cand_seqs, [cand_seqs],
message='cand seqs: ',
summarize=MAX_STEPS + 2)
# cand_seqs.set_shape([beam_size, MAX_STEPS+2])
cand_seqs = tf.reshape(cand_seqs, [beam_size, MAX_STEPS + 2])
cand_scores.set_shape([beam_size])
# completed_seqs.set_shape([beam_size, MAX_STEPS+2])
completed_seqs = tf.reshape(completed_seqs,
[beam_size, MAX_STEPS + 2])
s1_shape = [beam_size, self.attention_cell.state_size]
s2_shape = [beam_size, self.decoder_cell.state_size]
s3_shape = [beam_size, self.attn_context.context_size]
# prepare data for next step
# states = tf.gather(states, cand_parents, axis=0)
# states = self.select_states(states, cand_parents)
states = tuple(tf.gather(el, cand_parents) for el in states)
states[0].set_shape(s1_shape)
states[1].set_shape(s2_shape)
states[2].set_shape(s3_shape)
alphas = tf.gather(alphas, cand_parents, axis=1)
alphas_shape = [self.attn_context.num_encoder_states, beam_size]
alphas = tf.reshape(alphas, alphas_shape)
# alphas.set_shape(alphas_shape)
# 3. Update uncompleted sequences --------------------------------
ts = tf.add(ts, 1)
return ts, stop_decoder, states, alphas, cand_seqs, \
cand_scores, completed_scores, completed_scores_scaled, \
completed_seqs, completed_lens
def __init__(self, data, args, embed):
# 这里的输入和前面的seq2seq一致
self.posts = tf.placeholder(tf.int32, (None, None),
'enc_inps') # batch*len
self.posts_length = tf.placeholder(tf.int32, (None, ),
'enc_lens') # batch
self.prevs_length = tf.placeholder(tf.int32, (None, ),
'enc_lens_prev') # batch
self.origin_responses = tf.placeholder(tf.int32, (None, None),
'dec_inps') # batch*len
self.origin_responses_length = tf.placeholder(tf.int32, (None, ),
'dec_lens') # batch
# kgs表示该样例所在这段对话中所有的知识：[batch, max_kg_nums, max_kg_length]
# kgs_h_length表示每一个知识中head entity的长度：[batch, max_kg_nums]
# kgs_hr_length表示每一个知识中head entity和relation的长度：[batch, max_kg_nums]
# kgs_hrt_length表示每一个知识中h,r,t的长度：[batch, max_kg_nums]
# kgs_index表示当前这句话实际使用的kg的索引指示矩阵：[batch, max_kg_nums]（其中使用的知识对应为1，没有使用的知识对应为0）
self.kgs = tf.placeholder(tf.int32, (None, None, None), 'kg_inps')
self.kgs_h_length = tf.placeholder(tf.int32, (None, None), 'kg_h_lens')
self.kgs_hr_length = tf.placeholder(tf.int32, (None, None),
'kg_hr_lens')
self.kgs_hrt_length = tf.placeholder(tf.int32, (None, None),
'kg_hrt_lens')
self.kgs_index = tf.placeholder(tf.float32, (None, None), 'kg_indices')
# 用来平衡解码损失和kg损失的超参数
self.lamb = tf.placeholder(tf.float32, name='lamb')
self.is_train = tf.placeholder(tf.bool)
# deal with original data to adapt encoder and decoder
# 获取解码器的输入和输出
batch_size, decoder_len = tf.shape(self.origin_responses)[0], tf.shape(
self.origin_responses)[1]
self.responses = tf.split(self.origin_responses, [1, decoder_len - 1],
1)[1] # no go_id
self.responses_length = self.origin_responses_length - 1
self.responses_input = tf.split(self.origin_responses,
[decoder_len - 1, 1],
1)[0] # no eos_id
self.responses_target = self.responses
decoder_len = decoder_len - 1
# 获取编码器的输入
self.posts_input = self.posts # batch*len
# 对解码器的mask矩阵，对于pad的mask
self.decoder_mask = tf.reshape(
tf.cumsum(tf.one_hot(self.responses_length - 1, decoder_len),
reverse=True,
axis=1), [-1, decoder_len])
kg_len = tf.shape(self.kgs)[2]
#kg_len = tf.Print(kg_len, [batch_size, kg_len, decoder_len, self.kgs_length])
# kg_h_mask = tf.reshape(tf.cumsum(tf.one_hot(self.kgs_h_length-1,
# kg_len), reverse=True, axis=2), [batch_size, -1, kg_len, 1])
# 这里分别得到对于key（也就是hr）的mask矩阵：[batch_size, max_kg_nums, max_kg_length, 1]
# 以及对于value（也就是t）的mask矩阵：[batch_size, max_kg_nums, max_kg_length, 1]
kg_hr_mask = tf.reshape(
tf.cumsum(tf.one_hot(self.kgs_hr_length - 1, kg_len),
reverse=True,
axis=2), [batch_size, -1, kg_len, 1])
kg_hrt_mask = tf.reshape(
tf.cumsum(tf.one_hot(self.kgs_hrt_length - 1, kg_len),
reverse=True,
axis=2), [batch_size, -1, kg_len, 1])
kg_key_mask = kg_hr_mask
kg_value_mask = kg_hrt_mask - kg_hr_mask
# initialize the training process
self.learning_rate = tf.Variable(float(args.lr),
trainable=False,
dtype=tf.float32)
self.learning_rate_decay_op = self.learning_rate.assign(
self.learning_rate * args.lr_decay)
self.global_step = tf.Variable(0, trainable=False)
# build the embedding table and embedding input
if embed is None:
# initialize the embedding randomly
self.embed = tf.get_variable(
'embed', [data.vocab_size, args.embedding_size], tf.float32)
else:
# initialize the embedding by pre-trained word vectors
self.embed = tf.get_variable('embed',
dtype=tf.float32,
initializer=embed)
# encoder_input: [batch, encoder_len, embed_size]
self.encoder_input = tf.nn.embedding_lookup(self.embed, self.posts)
# decoder_input: [batch, decoder_len, embed_size]
self.decoder_input = tf.nn.embedding_lookup(self.embed,
self.responses_input)
# kg_input: [batch, max_kg_nums, max_kg_length, embed_size]
self.kg_input = tf.nn.embedding_lookup(self.embed, self.kgs)
#self.encoder_input = tf.cond(self.is_train,
# lambda: tf.nn.dropout(tf.nn.embedding_lookup(self.embed, self.posts_input), 0.8),
# lambda: tf.nn.embedding_lookup(self.embed, self.posts_input)) #batch*len*unit
#self.decoder_input = tf.cond(self.is_train,
# lambda: tf.nn.dropout(tf.nn.embedding_lookup(self.embed, self.responses_input), 0.8),
# lambda: tf.nn.embedding_lookup(self.embed, self.responses_input))
# build rnn_cell
cell_enc = tf.nn.rnn_cell.GRUCell(args.eh_size)
cell_dec = tf.nn.rnn_cell.GRUCell(args.dh_size)
# build encoder
with tf.variable_scope('encoder'):
encoder_output, encoder_state = tf.nn.dynamic_rnn(
cell_enc,
self.encoder_input,
self.posts_length,
dtype=tf.float32,
scope="encoder_rnn")
# key对应一个知识h,r的词向量的均值 [batch, max_kg_nums, embed_size]
# value对应一个知识t的词向量的均值 [batch, max_kg_nums, embed_size]
self.kg_key_avg = tf.reduce_sum(
self.kg_input * kg_key_mask, axis=2) / tf.maximum(
tf.reduce_sum(kg_key_mask, axis=2),
tf.ones_like(tf.expand_dims(self.kgs_hrt_length, -1),
dtype=tf.float32))
self.kg_value_avg = tf.reduce_sum(
self.kg_input * kg_value_mask, axis=2) / tf.maximum(
tf.reduce_sum(kg_value_mask, axis=2),
tf.ones_like(tf.expand_dims(self.kgs_hrt_length, -1),
dtype=tf.float32))
# 将编码器的输出状态映射到embed_size的维度
# query: [batch, 1, embed_size]
with tf.variable_scope('knowledge'):
query = tf.reshape(
tf.layers.dense(tf.concat(encoder_state, axis=-1),
args.embedding_size,
use_bias=False),
[batch_size, 1, args.embedding_size])
# [batch, max_kg_nums]
kg_score = tf.reduce_sum(query * self.kg_key_avg, axis=2)
# 对于hrt大于0的位置（即该位置存在知识），取对应的kg_score，否则对应位置为-inf
kg_score = tf.where(tf.greater(self.kgs_hrt_length, 0), kg_score,
-tf.ones_like(kg_score) * np.inf)
# 计算每个知识对应的分数 [batch, max_kg_nums]
kg_alignment = tf.nn.softmax(kg_score)
# 根据计算的kg注意力分数的位置，计算关注的kg准确率和损失
kg_max = tf.argmax(kg_alignment, axis=-1)
kg_max_onehot = tf.one_hot(kg_max,
tf.shape(kg_alignment)[1],
dtype=tf.float32)
self.kg_acc = tf.reduce_sum(
kg_max_onehot * self.kgs_index) / tf.maximum(
tf.reduce_sum(tf.reduce_max(self.kgs_index, axis=-1)),
tf.constant(1.0))
self.kg_loss = tf.reduce_sum(
-tf.log(tf.clip_by_value(kg_alignment, 1e-12, 1.0)) *
self.kgs_index,
axis=1) / tf.maximum(tf.reduce_sum(self.kgs_index, axis=1),
tf.ones([batch_size], dtype=tf.float32))
self.kg_loss = tf.reduce_mean(self.kg_loss)
# 得到注意力之后的知识的嵌入：[batch, embed_size]
self.knowledge_embed = tf.reduce_sum(
tf.expand_dims(kg_alignment, axis=-1) * self.kg_value_avg, axis=1)
# 对维度进行扩充[batch, decoder_len, embed_size]
knowledge_embed_extend = tf.tile(
tf.expand_dims(self.knowledge_embed, axis=1), [1, decoder_len, 1])
# 将知识和原始的解码输入拼接，作为新的解码输入 [batch, decoder_len, 2*embed_size]
self.decoder_input = tf.concat(
[self.decoder_input, knowledge_embed_extend], axis=2)
# get output projection function
output_fn = MyDense(data.vocab_size, use_bias=True)
sampled_sequence_loss = output_projection_layer(
args.dh_size, data.vocab_size, args.softmax_samples)
encoder_len = tf.shape(encoder_output)[1]
posts_mask = tf.sequence_mask(self.posts_length, encoder_len)
prevs_mask = tf.sequence_mask(self.prevs_length, encoder_len)
attention_mask = tf.reshape(tf.logical_xor(posts_mask, prevs_mask),
[batch_size, encoder_len])
# construct helper and attention
train_helper = tf.contrib.seq2seq.TrainingHelper(
self.decoder_input, self.responses_length)
#infer_helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(self.embed, tf.fill([batch_size], data.go_id), data.eos_id)
# 为了在推理的时候，每一次的输入都是上一次输出和知识的拼接
infer_helper = MyInferenceHelper(self.embed,
tf.fill([batch_size], data.go_id),
data.eos_id, self.knowledge_embed)
#attn_mechanism = tf.contrib.seq2seq.BahdanauAttention(args.dh_size, encoder_output,
# memory_sequence_length=self.posts_length)
# 这里的MyAttention主要解决BahdanauAttention只能输入编码序列长度的问题
attn_mechanism = MyAttention(args.dh_size, encoder_output,
attention_mask)
cell_dec_attn = tf.contrib.seq2seq.AttentionWrapper(
cell_dec, attn_mechanism, attention_layer_size=args.dh_size)
enc_state_shaping = tf.layers.dense(encoder_state,
args.dh_size,
activation=None)
dec_start = cell_dec_attn.zero_state(
batch_size, dtype=tf.float32).clone(cell_state=enc_state_shaping)
# build decoder (train)
with tf.variable_scope('decoder'):
decoder_train = tf.contrib.seq2seq.BasicDecoder(
cell_dec_attn, train_helper, dec_start)
train_outputs, _, _ = tf.contrib.seq2seq.dynamic_decode(
decoder_train, impute_finished=True, scope="decoder_rnn")
self.decoder_output = train_outputs.rnn_output
#self.decoder_output = tf.nn.dropout(self.decoder_output, 0.8)
# 输出概率分布和解码损失
self.decoder_distribution_teacher, self.decoder_loss, self.decoder_all_loss = \
sampled_sequence_loss(self.decoder_output, self.responses_target, self.decoder_mask)
# build decoder (test)
with tf.variable_scope('decoder', reuse=True):
decoder_infer = tf.contrib.seq2seq.BasicDecoder(
cell_dec_attn, infer_helper, dec_start, output_layer=output_fn)
infer_outputs, _, _ = tf.contrib.seq2seq.dynamic_decode(
decoder_infer,
impute_finished=True,
maximum_iterations=args.max_decoder_length,
scope="decoder_rnn")
# 输出解码概率分布
self.decoder_distribution = infer_outputs.rnn_output
self.generation_index = tf.argmax(
tf.split(self.decoder_distribution, [2, data.vocab_size - 2],
2)[1], 2) + 2 # for removing UNK
# calculate the gradient of parameters and update
self.params = [
k for k in tf.trainable_variables() if args.name in k.name
]
opt = tf.train.AdamOptimizer(self.learning_rate)
# 将解码损失和kg损失相加
self.loss = self.decoder_loss + self.lamb * self.kg_loss
gradients = tf.gradients(self.loss, self.params)
clipped_gradients, self.gradient_norm = tf.clip_by_global_norm(
gradients, args.grad_clip)
self.update = opt.apply_gradients(zip(clipped_gradients, self.params),
global_step=self.global_step)
# save checkpoint
self.latest_saver = tf.train.Saver(
write_version=tf.train.SaverDef.V2,
max_to_keep=args.checkpoint_max_to_keep,
pad_step_number=True,
keep_checkpoint_every_n_hours=1.0)
self.best_saver = tf.train.Saver(write_version=tf.train.SaverDef.V2,
max_to_keep=1,
pad_step_number=True,
keep_checkpoint_every_n_hours=1.0)
# create summary for tensorboard
self.create_summary(args)
def rpn_find_positive_negative_samples(self, anchors):
'''
assign anchors targets: object or background.
:param anchors: [valid_num_of_anchors, 5]. use N to represent valid_num_of_anchors
:return:labels. anchors_matched_gtboxes, object_mask
labels shape is [N, ]. positive is 1, negative is 0, ignored is -1
anchor_matched_gtboxes. each anchor's gtbox(only positive box has gtbox)shape is [N, 5]
object_mask. tf.float32. 1.0 represent box is object, 0.0 is others. shape is [N, ]
'''
with tf.variable_scope('rpn_find_positive_negative_samples'):
gtboxes = tf.reshape(self.gtboxes_and_label[:, :-1], [-1, 5])
gtboxes = tf.cast(gtboxes, tf.float32)
# [N, M]
ious = tf_wrapper.get_iou_matrix_tf(anchors,
gtboxes,
use_gpu=cfgs.IOU_USE_GPU,
gpu_id=0)
# ious = tf.reshape(ious, [tf.shape(anchors)[0], tf.shape(gtboxes)[0]])
max_iou_each_row = tf.reduce_max(ious, axis=1)
labels = tf.ones(shape=[
tf.shape(anchors)[0],
], dtype=tf.float32) * (-1) # [N, ] # ignored is -1
matchs = tf.cast(tf.argmax(ious, axis=1), tf.int32)
# matchs = matchs * tf.cast(positives, dtype=matchs.dtype) # remove background and ignored
anchors_matched_gtboxes = tf.gather(gtboxes, matchs) # [N, 5]
negatives = tf.less(max_iou_each_row,
self.rpn_iou_negative_threshold)
negatives = tf.logical_and(negatives,
tf.greater(max_iou_each_row, 0.1))
# here we set anchors whose anchor-gtboxes iou between 0.1 and 0.3 as negatives
if self.use_angles_condition:
# an anchor that has an IoU overlap higher than 0.7 with any ground-truth box
cond1 = tf.greater_equal(
max_iou_each_row,
self.rpn_iou_positive_threshold) # iou >= 0.7 is positive
# angle condition
gtboxes_angles = anchors_matched_gtboxes[:,
-1] # tf.unstack(anchors_matched_gtboxes, axis=1)
anchors_angles = anchors[:, -1] # tf.unstack(anchors, axis=1)
cond2 = tf.less_equal(tf.abs(gtboxes_angles - anchors_angles),
self.anchor_angle_threshold)
cond3 = tf.greater(tf.abs(gtboxes_angles - anchors_angles),
self.anchor_angle_threshold)
positives1 = tf.logical_and(cond1, cond2)
negatives = tf.logical_or(negatives,
tf.logical_and(cond1, cond3))
else:
positives1 = tf.greater_equal(max_iou_each_row,
self.rpn_iou_positive_threshold)
# to avoid none of boxes iou >= 0.7, use max iou boxes as positive
max_iou_each_column = tf.reduce_max(ious, 0)
# the anchor/anchors with the highest Intersection-over-Union (IoU) overlap with a ground-truth box
positives2 = tf.reduce_sum(tf.cast(
tf.equal(ious, max_iou_each_column), tf.float32),
axis=1)
positives = tf.logical_or(positives1, tf.cast(positives2, tf.bool))
labels += 2 * tf.cast(
positives,
tf.float32) # Now, positive is 1, ignored and background is -1
# object_mask = tf.cast(positives, tf.float32) # 1.0 is object, 0.0 is others
# background's gtboxes tmp set the first gtbox, it dose not matter, because use object_mask will ignored it
labels += tf.cast(
negatives, tf.float32
) # [N, ] positive is >=1.0, negative is 0, ignored is -1.0
'''
Need to note: when opsitive, labels may >= 1.0.
Because, when all the iou< 0.7, we set anchors having max iou each column as positive.
these anchors may have iou < 0.3.
We will show you the steps as following:
For those anchors whose iou < 0.3 but having max iou at some columns.
1. In the begining, labels is [-1, -1, -1...-1]
2. labels are [1..1]. Because their iou are max at some columns.(labels +=2 * positives)
3. labels are [2..2]. Because their iou < 0.3. (labels += negatives)
So, the final result will be 2.0
So, when opsitive, labels may in [1.0, 2.0]. that is labels >=1.0
So we add following codes to avoid that.
'''
positives = tf.cast(tf.greater_equal(labels, 1.0), tf.float32)
ignored = tf.cast(tf.equal(labels, -1.0), tf.float32) * -1
labels = positives + ignored
object_mask = tf.cast(positives,
tf.float32) # 1.0 is object, 0.0 is others
return labels, anchors_matched_gtboxes, object_mask
[real_num_detection, -1])
detection_masks = tf.slice(detection_masks, [0, 0, 0],
[real_num_detection, -1, -1])
# detection_masks = tf.expand_dims(detection_masks, 0)
detection_scores = detection_graph.get_tensor_by_name(
'detection_scores:0')
detection_classes = detection_graph.get_tensor_by_name(
'detection_classes:0')
image_shape = tf.shape(image_tensor)
detection_masks_reframed = utils_ops.reframe_box_masks_to_image_masks(
detection_masks, detection_boxes, image_shape[1],
image_shape[2])
detection_masks_reframed = tf.cast(
tf.greater(detection_masks_reframed, 0.5), tf.uint8)
detection_masks_reframed = tf.expand_dims(detection_masks_reframed,
0)
# image_shape = tf.shape(image)
# import pdb;
# pdb.set_trace()
# shuffle(all_classes)
count = 0
for index, row in df.iterrows():
print(str(index) + ' / ' + str(count) + ' / ' + str(len(df)))
image_path = test_data_path + '/' + row['ImageId']
#############################################
# Check if anchors' centers are in boxes area
ycenter2, xcenter2, _, _ = BoxList.get_center_coordinates_and_sizes(anchors)
gt_boxes_tensor = tf.convert_to_tensor(gt_boxes_array)
gt_boxes_broadcast_ymin = tf.squeeze(
tf.slice(gt_boxes_tensor, (0, 0), (gt_boxes_tensor.shape[0], 1)))
gt_boxes_broadcast_xmin = tf.squeeze(
tf.slice(gt_boxes_tensor, (0, 1), (gt_boxes_tensor.shape[0], 1)))
gt_boxes_broadcast_ymax = tf.squeeze(
tf.slice(gt_boxes_tensor, (0, 2), (gt_boxes_tensor.shape[0], 1)))
gt_boxes_broadcast_xmax = tf.squeeze(
tf.slice(gt_boxes_tensor, (0, 3), (gt_boxes_tensor.shape[0], 1)))
is_in_xmin = tf.greater(xcenter2 - tf.transpose([gt_boxes_broadcast_xmin]), 0)
is_in_ymin = tf.greater(ycenter2 - tf.transpose([gt_boxes_broadcast_ymin]), 0)
is_in_xmax = tf.less(xcenter2 - tf.transpose([gt_boxes_broadcast_xmax]), 0)
is_in_ymax = tf.less(ycenter2 - tf.transpose([gt_boxes_broadcast_ymax]), 0)
selected_anchors_by_center_in_area = tf.logical_and(
tf.logical_and(is_in_xmin, is_in_ymin),
tf.logical_and(is_in_xmax, is_in_ymax))
# Mask similarly to selected_anchors_by_threshold or selected_anchors_by_distance
selected_anchors_by_center_in_area = tf.cast(
selected_anchors_by_center_in_area, tf.int32)
#############################################
# Rest of the process
selected_anchors_by_distance = tf.cast(
def dXdt(X, t): # X is the state vector
V_p = X[0 : p_n] # Voltage(PN)
V_l = X[p_n : n_n] # Voltage(LN)
n_K = X[n_n : 2*n_n] # K-gating(ALL)
m_Na = X[2*n_n : 2*n_n + p_n] # Na-activation-gating(PN)
h_Na = X[2*n_n + p_n : 2*n_n + 2*p_n] # Na-inactivation-gating(PN)
m_A = X[2*n_n + 2*p_n : 2*n_n + 3*p_n] # Transient-K-activation-gating(PN)
h_A = X[2*n_n + 3*p_n : 2*n_n + 4*p_n] # Transient-K-inactivation-gating(PN)
m_Ca = X[2*n_n + 4*p_n : 2*n_n + 4*p_n + l_n] # Ca-activation-gating(LN)
h_Ca = X[2*n_n + 4*p_n + l_n: 2*n_n + 4*p_n + 2*l_n] # Ca-inactivation-gating(LN)
m_KCa = X[2*n_n + 4*p_n + 2*l_n : 2*n_n + 4*p_n + 3*l_n] # K(Ca)-gating(LN)
Ca = X[2*n_n + 4*p_n + 3*l_n: 2*n_n + 4*p_n + 4*l_n] # Ca-concentration(LN)
o_ach = X[6*n_n : 6*n_n + n_syn_ach] # Acetylcholine Open Fraction
o_fgaba = X[6*n_n + n_syn_ach : 6*n_n + n_syn_ach + n_syn_fgaba] # GABAa Open Fraction
r_sgaba = X[6*n_n + n_syn_ach + n_syn_fgaba : 6*n_n + n_syn_ach + n_syn_fgaba + n_syn_sgaba] # GABAa Open Fraction
g_sgaba = X[6*n_n + n_syn_ach + n_syn_fgaba + n_syn_sgaba : 6*n_n + n_syn_ach + n_syn_fgaba + 2*n_syn_sgaba] # GABAa Open Fraction
fire_t = X[-n_n:] # Fire-times
V = X[:n_n] # Overall Voltage (PN + LN)
# Evaluate Differentials for Gating variables and Ca concentration
n0,tn = K_prop(V)
dn_k = - (1.0/tn)*(n_K-n0)
m0,tm,h0,th = Na_prop(V_p)
dm_Na = - (1.0/tm)*(m_Na-m0)
dh_Na = - (1.0/th)*(h_Na-h0)
m0,tm,h0,th = A_prop(V_p)
dm_A = - (1.0/tm)*(m_A-m0)
dh_A = - (1.0/th)*(h_A-h0)
m0,tm,h0,th = Ca_prop(V_l)
dm_Ca = - (1.0/tm)*(m_Ca-m0)
dh_Ca = - (1.0/th)*(h_Ca-h0)
m0,tm = KCa_prop(Ca)
dm_KCa = - (1.0/tm)*(m_KCa-m0)
dCa = - A_Ca*I_Ca(V_l,m_Ca,h_Ca) - (Ca - Ca0)/t_Ca
# Evaluate differential for Voltage
CmdV_p = - I_Na(V_p, m_Na, h_Na) - I_A(V_p, m_A, h_A)
CmdV_l = - I_Ca(V_l, m_Ca, h_Ca) - I_KCa(V_l, m_KCa)
# Once we have that, we merge the two into a single 120-vector.
CmdV = tf.concat([CmdV_p,CmdV_l],0)
# Finally we add the common currents and divide by Cm to get dV/dt.
dV = (I_inj_t(t) + CmdV - I_K(V, n_K) - I_L(V) - I_ach(o_ach,V) - I_fgaba(o_fgaba,V) - I_sgaba(g_sgaba,V)) / C_m
# Evaluate dynamics in synapses
A_ = tf.constant(A,dtype=tf.float64)
T_ach = tf.where(tf.logical_and(tf.greater(t,fire_t+t_delay),tf.less(t,fire_t+t_max+t_delay)),A_,tf.zeros(tf.shape(A_),dtype=A_.dtype))
T_ach = tf.multiply(tf.constant(ach_mat,dtype=tf.float64),T_ach)
T_ach = tf.boolean_mask(tf.reshape(T_ach,(-1,)),ach_mat.reshape(-1) == 1)
do_achdt = alp_ach*(1.0-o_ach)*T_ach - bet_ach*o_ach
T_fgaba = 1.0/(1.0+tf.exp(-(V-V0)/sigma))
T_fgaba = tf.multiply(tf.constant(fgaba_mat,dtype=tf.float64),T_fgaba)
T_fgaba = tf.boolean_mask(tf.reshape(T_fgaba,(-1,)),fgaba_mat.reshape(-1) == 1)
do_fgabadt = alp_fgaba*(1.0-o_fgaba)*T_fgaba - bet_fgaba*o_fgaba
dg_sgabadt = - np.array(r4_sgaba)*g_sgaba + np.array(r3_sgaba)*r_sgaba
A_ = tf.constant(A,dtype=tf.float64)
T_sgaba = tf.where(tf.logical_and(tf.greater(t,fire_t+t_delay),tf.less(t,fire_t+t_max+t_delay)),A_,tf.zeros(tf.shape(A_),dtype=A_.dtype))
T_sgaba = tf.multiply(tf.constant(sgaba_mat,dtype=tf.float64),T_sgaba)
T_sgaba = tf.boolean_mask(tf.reshape(T_sgaba,(-1,)),sgaba_mat.reshape(-1) == 1)
dr_sgabadt = r1_sgaba*(1.0-r_sgaba)*T_sgaba - r2_sgaba*r_sgaba
# Set change in fire-times as zero
dfdt = tf.zeros(tf.shape(fire_t),dtype=fire_t.dtype)
# Combine to a single vector
out = tf.concat([dV, dn_k,
dm_Na, dh_Na,
dm_A, dh_A,
dm_Ca, dh_Ca,
dm_KCa,
dCa, do_achdt,
do_fgabadt, dr_sgabadt,
dg_sgabadt, dfdt ],0)
return out
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
n_cpu = multiprocessing.cpu_count()
if sys.platform == 'darwin':
n_cpu //= 2
self.graph = tf.Graph()
with self.graph.as_default():
self.sess = tf_util.make_session(num_cpu=n_cpu, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, LstmPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_fn
vpredclipped = self.old_vpred_ph + tf.clip_by_value(
train_model.value_fn - self.old_vpred_ph, - self.clip_range_ph, self.clip_range_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpredclipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.to_float(tf.greater(tf.abs(ratio - 1.0), self.clip_range_ph)))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leiber', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.scalar('old_neglog_action_probabilty', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.histogram('old_neglog_action_probabilty', self.old_neglog_pac_ph)
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if len(self.observation_space.shape) == 3:
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
vgg16_Features = tf.reshape(net, (-1, 4096))
# Convert end_points_collection into a end_point dict.
end_points = slim.utils.convert_collection_to_dict(
end_points_collection)
RNN_inputs = tf.reshape(vgg16_Features[0, :], (-1, feature_size))
h_1, curr_state1 = RNNCell(W_RNN1, b_RNN1, RNN_inputs, curr_state1)
# h_1, curr_state1 = lstm_cell(W_lstm1, b_lstm1, 1.0, inputs, curr_state1)
#curr_state1 = tf.reshape(curr_state1[0], (-1,n_hidden1))
fc1 = tf.matmul(h_1, W_fc1) + b_fc1
print(fc1[0, :].shape, vgg16_Features[1, :].shape)
sseLoss1 = tf.square(tf.subtract(fc1[0, :], vgg16_Features[1, :]))
mask = tf.greater(sseLoss1, learnError * tf.ones_like(sseLoss1))
sseLoss1 = tf.multiply(sseLoss1, tf.cast(mask, tf.float32))
sseLoss = tf.reduce_mean(sseLoss1)
#####################
### Training loop ###
#####################
init = tf.global_variables_initializer()
saver = tf.train.Saver(max_to_keep=0)
with tf.Session() as sess:
# Initialize parameters
sess.run(init)
saver.restore(sess, modelPath)
def leaky_relu(x):
return tf.where(tf.greater(x, 0), x, 0.01 * x)
def rpn_losses(self):
with tf.variable_scope('rpn_losses'):
minibatch_indices, minibatch_anchor_matched_gtboxes, \
object_mask, minibatch_labels_one_hot = self.make_minibatch(self.anchors)
minibatch_anchors = tf.gather(self.anchors, minibatch_indices)
minibatch_encode_boxes = tf.gather(self.rpn_encode_boxes,
minibatch_indices)
minibatch_boxes_scores = tf.gather(self.rpn_scores,
minibatch_indices)
# encode gtboxes
minibatch_encode_gtboxes = encode_and_decode.encode_boxes(
unencode_boxes=minibatch_anchor_matched_gtboxes,
reference_boxes=minibatch_anchors,
scale_factors=self.scale_factors)
positive_anchors_in_img = draw_box_with_color(
self.img_batch,
minibatch_anchors * tf.expand_dims(object_mask, 1),
text=tf.shape(tf.where(tf.equal(object_mask, 1.0)))[0])
negative_mask = tf.cast(
tf.logical_not(tf.cast(object_mask, tf.bool)), tf.float32)
negative_anchors_in_img = draw_box_with_color(
self.img_batch,
minibatch_anchors * tf.expand_dims(negative_mask, 1),
text=tf.shape(tf.where(tf.equal(object_mask, 0.0)))[0])
minibatch_decode_boxes = encode_and_decode.decode_boxes(
encode_boxes=minibatch_encode_boxes,
reference_boxes=minibatch_anchors,
scale_factors=self.scale_factors)
tf.summary.image('/positive_anchors', positive_anchors_in_img)
tf.summary.image('/negative_anchors', negative_anchors_in_img)
minibatch_boxes_softmax_scores = tf.gather(
slim.softmax(self.rpn_scores), minibatch_indices)
top_k_scores, top_k_indices = tf.nn.top_k(
minibatch_boxes_softmax_scores[:, 1], k=20)
top_k_boxes = tf.gather(minibatch_decode_boxes, top_k_indices)
top_detections_in_img = draw_boxes_with_scores(self.img_batch,
boxes=top_k_boxes,
scores=top_k_scores)
tf.summary.image('/top_20', top_detections_in_img)
temp_indices = tf.reshape(
tf.where(tf.greater(top_k_scores, cfgs.FINAL_SCORE_THRESHOLD)),
[-1])
rpn_predict_boxes = tf.gather(top_k_boxes, temp_indices)
rpn_predict_scores = tf.gather(top_k_scores, temp_indices)
# losses
with tf.variable_scope('rpn_location_loss'):
location_loss = losses.l1_smooth_losses(
predict_boxes=minibatch_encode_boxes,
gtboxes=minibatch_encode_gtboxes,
object_weights=object_mask)
slim.losses.add_loss(
location_loss) # add smooth l1 loss to losses collection
with tf.variable_scope('rpn_classification_loss'):
classification_loss = slim.losses.softmax_cross_entropy(
logits=minibatch_boxes_scores,
onehot_labels=minibatch_labels_one_hot)
return location_loss, classification_loss, rpn_predict_boxes, rpn_predict_scores
def build_train_op(
self
): # Set computing the gradient wrt for the group assignment variables
# Learning rate
tf.summary.scalar(
(self._name + "/" if self._name else "") + 'learing_rate', self.lr)
# Optimizer and gradients for each GPU
opt = tf.train.MomentumOptimizer(self.lr, self._hp.momentum)
all_vars = tf.trainable_variables()
group_vars = [v for v in all_vars if v.name.startswith('group/')]
model_vars = [v for v in all_vars if not v.name.startswith('group/')]
self._gv_list_task_loss = []
self._gv_group_loss = []
# Computer gradients for each GPU
for i in range(self._hp.num_gpus):
with tf.device('/GPU:%d' % i), tf.variable_scope(
tf.get_variable_scope()):
with tf.name_scope('tower_%d/' % i) as scope:
print('Compute gradients of tower: %s' % scope)
if self._reuse_weights or i > 0:
tf.get_variable_scope().reuse_variables()
losses = []
# Add l2 loss
if self._hp.weight_decay > 0.0:
with tf.variable_scope('l2_loss'):
costs = [
tf.nn.l2_loss(var) for var in
tf.get_collection(utils.WEIGHT_DECAY_KEY)
]
l2_loss = tf.multiply(self._hp.weight_decay,
tf.add_n(costs))
losses.append(l2_loss)
# Add group split loss
with tf.variable_scope('group'):
if tf.get_collection(
'OVERLAP_LOSS') and self._hp.gamma1 > 0.0:
cost1 = tf.reduce_mean(
tf.get_collection('OVERLAP_LOSS'))
cost1 = cost1 * self._hp.gamma1
if i == 0:
tf.summary.scalar('group/overlap_loss/', cost1)
losses.append(cost1)
if tf.get_collection(
'WEIGHT_SPLIT') and self._hp.gamma2 > 0.0:
if self._hp.weighted_group_loss:
reg_weights = [
tf.stop_gradient(x)
for x in tf.get_collection('WEIGHT_SPLIT')
]
regs = [
tf.stop_gradient(x) * x
for x in tf.get_collection('WEIGHT_SPLIT')
]
cost2 = tf.reduce_sum(regs) / tf.reduce_sum(
reg_weights)
else:
cost2 = tf.reduce_mean(
tf.get_collection('WEIGHT_SPLIT'))
cost2 = cost2 * self._hp.gamma2
if i == 0:
tf.summary.scalar('group/weight_split_loss/',
cost2)
losses.append(cost2)
if tf.get_collection(
'UNIFORM_LOSS') and self._hp.gamma3 > 0.0:
cost3 = tf.reduce_mean(
tf.get_collection('UNIFORM_LOSS'))
cost3 = cost3 * self._hp.gamma3
if i == 0:
tf.summary.scalar('group/group_uniform_loss/',
cost3)
losses.append(cost3)
if losses:
total_loss = self._loss_list[i] + tf.add_n(losses)
# Compute gradients of total loss
grads_and_vars = opt.compute_gradients(
self._loss_list[i], model_vars)
# Append gradients and vars
self._gv_list_task_loss.append(grads_and_vars)
# Computer gradients of regularization loss
# It needs one more GPU
with tf.device('/GPU:%d' % self._hp.num_gpus), tf.variable_scope(
tf.get_variable_scope()):
with tf.name_scope('tower_group/') as scope:
print('Compute gradients of regularization loss: %s' % scope)
if self._reuse_weights:
tf.get_variable_scope().reuse_variables()
losses = []
# Add l2 loss
if self._hp.weight_decay > 0.0:
with tf.variable_scope('l2_loss'):
costs = [
tf.nn.l2_loss(var) for var in tf.get_collection(
utils.WEIGHT_DECAY_KEY)
]
l2_loss = tf.multiply(self._hp.weight_decay,
tf.add_n(costs))
losses.append(l2_loss)
# Add group split loss
with tf.variable_scope('group'):
if tf.get_collection(
'OVERLAP_LOSS') and self._hp.gamma1 > 0.0:
cost1 = tf.reduce_mean(
tf.get_collection('OVERLAP_LOSS'))
cost1 = cost1 * self._hp.gamma1
if i == 0:
tf.summary.scalar('group/overlap_loss/', cost1)
losses.append(cost1)
if tf.get_collection(
'WEIGHT_SPLIT') and self._hp.gamma2 > 0.0:
if self._hp.weighted_group_loss:
reg_weights = [
tf.stop_gradient(x)
for x in tf.get_collection('WEIGHT_SPLIT')
]
regs = [
tf.stop_gradient(x) * x
for x in tf.get_collection('WEIGHT_SPLIT')
]
cost2 = tf.reduce_sum(regs) / tf.reduce_sum(
reg_weights)
else:
cost2 = tf.reduce_mean(
tf.get_collection('WEIGHT_SPLIT'))
cost2 = cost2 * self._hp.gamma2
if i == 0:
tf.summary.scalar('group/weight_split_loss/',
cost2)
losses.append(cost2)
if tf.get_collection(
'UNIFORM_LOSS') and self._hp.gamma3 > 0.0:
cost3 = tf.reduce_mean(
tf.get_collection('UNIFORM_LOSS'))
cost3 = cost3 * self._hp.gamma3
if i == 0:
tf.summary.scalar('group/group_uniform_loss/',
cost3)
losses.append(cost3)
if losses:
# Compute gradients of total loss
total_loss = tf.add_n(losses)
self._gv_group_loss = opt.compute_gradients(
total_loss, all_vars)
# Merge gradients
print('Average gradients')
with tf.device('/CPU:0'):
grads_and_vars = self._average_gradients2(self._gv_list_task_loss,
self._gv_group_loss)
# Finetuning
if self._hp.finetune:
for idx, (grad, var) in enumerate(grads_and_vars):
if "group" in var.op.name or \
(("conv3_" in var.op.name) and self._hp.ngroups3 > 1) or \
(("conv4_" in var.op.name) and self._hp.ngroups2 > 1) or \
("conv5_" in var.op.name) or \
"logits" in var.op.name:
print('\tScale up learning rate of % s by 10.0' %
var.op.name)
grad = 10.0 * grad
grads_and_vars[idx] = (grad, var)
# Reduced gradient
eps = 1e-5
for idx, (grad, var) in enumerate(grads_and_vars):
if "group" in var.name:
print('\tApply reduced gradient on ' + var.name)
ngroups, dim = var.get_shape().as_list()
zeros = tf.zeros((ngroups, dim), dtype=tf.float32)
zeros_col = tf.zeros((ngroups, ), dtype=tf.float32)
zeros_row = tf.zeros((dim, ), dtype=tf.float32)
ones = tf.ones((ngroups, dim), dtype=tf.float32)
ones_col = tf.ones((ngroups, ), dtype=tf.float32)
ones_row = tf.ones((dim, ), dtype=tf.float32)
mu = tf.cast(tf.argmax(var, 0), dtype=tf.int32)
offset = tf.constant([ngroups * i for i in range(dim)],
dtype=tf.int32)
mask = tf.cast(tf.transpose(tf.one_hot(mu, ngroups)),
dtype=tf.bool)
grad_mu = tf.gather(tf.reshape(tf.transpose(grad), [-1]),
mu + offset)
grad_mu_tile = tf.tile(tf.reshape(grad_mu, [1, -1]),
[ngroups, 1])
grad_1 = grad - grad_mu_tile
grad_2 = tf.where(
tf.logical_and(tf.less_equal(var, ones * eps),
tf.greater(grad_1, zeros)), zeros,
grad_1)
grad_red_mu = -tf.reduce_sum(grad_2, 0)
grad_red_mu = tf.tile(tf.reshape(grad_red_mu, [1, -1]),
[ngroups, 1])
grad_red = tf.where(mask, grad_red_mu, grad_2)
max_step_size = tf.where(tf.greater(grad_red, zeros),
var / grad_red, ones)
max_step_size = tf.reduce_min(max_step_size, 0)
lr_mult = tf.where(tf.less(max_step_size, self.lr),
max_step_size / self.lr, ones_row)
# lr_mult = tf.where(tf.less(max_step_size, self.lr*10.0), max_step_size/self.lr/10.0, ones_row)
grad_red = grad_red * lr_mult
grads_and_vars[idx] = (grad_red, var)
tf.summary.scalar(var.op.name + "/lr_mult_min",
tf.reduce_min(lr_mult))
tf.summary.scalar(var.op.name + "/lr_mult_avg",
tf.reduce_mean(lr_mult))
tf.summary.histogram(var.op.name + "/group_sum",
tf.reduce_sum(var, 0))
tf.summary.scalar(var.op.name + "/sparsity",
tf.nn.zero_fraction(var - eps))
tf.summary.histogram(var.op.name + "/grad", grad_red)
# Apply gradient
apply_grad_op = opt.apply_gradients(grads_and_vars,
global_step=self._global_step)
# Batch normalization moving average update
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
self.train_op = tf.group(*(update_ops + [apply_grad_op]),
name="train_op")
# Build validity op
print('Build validity op')
with tf.device('/CPU:0'):
# Force the group variable to be non-negative and sum-to-one
validity_op_list = []
with tf.name_scope("sum-to-one"):
for var in tf.trainable_variables():
if "group" in var.name:
ngroups, dim = var.get_shape().as_list()
ones = tf.ones((ngroups, dim), dtype=tf.float32)
zeros = tf.zeros((ngroups, dim), dtype=tf.float32)
var_temp = tf.where(tf.less(var, ones * eps),
ones * eps, var) # non-negativity
var_temp = var_temp / tf.reduce_sum(var_temp,
0) # sum-to-one
assign_op = var.assign(var_temp)
validity_op_list.append(assign_op)
self.validity_op = tf.group(*validity_op_list,
name="group_validity")
def drelu(x):
zero = tf.zeros(x.get_shape())
one = tf.ones(x.get_shape())
return (tf.where(tf.greater(x, zero), one, zero))
with tf.name_scope('layer1'):
zy = zm + tf.sqrt(zv) * z
h1 = custom_layer(zy, reuse)
h2 = Dense(h1, 512, 'layer2', tf.nn.relu, reuse=reuse)
h3 = Dense(h2, 512, 'layer3', tf.nn.relu, reuse=reuse)
h4 = Dense(h3, 512, 'layer4', tf.nn.relu, reuse=reuse)
px_logit = Dense(h2, 784, 'logit', reuse=reuse)
return px_logit
tf.reset_default_graph()
x = Placeholder((None, 784), 'x')
# binarize data and create a y "placeholder"
with tf.name_scope('x_binarized'):
xb = tf.cast(tf.greater(x, tf.random_uniform(tf.shape(x), 0, 1)),
tf.float32)
with tf.name_scope('y_'):
y_ = tf.fill(tf.pack([tf.shape(x)[0], 10]), 0.0)
# propose distribution over y
qy_logit, qy = qy_graph(xb)
# for each proposed y, infer z and reconstruct x
z, zm, zv, px_logit = [[None] * 10 for i in xrange(4)]
for i in xrange(10):
with tf.name_scope('graphs/hot_at{:d}'.format(i)):
y = tf.add(y_, Constant(np.eye(10)[i], name='hot_at_{:d}'.format(i)))
z[i], zm[i], zv[i] = qz_graph(xb, y)
px_logit[i] = px_graph(z[i], y)
def box_voting(selected_boxes, pool_boxes, iou_thresh=0.5):
"""Performs box voting as described in S. Gidaris and N. Komodakis, ICCV 2015.
Performs box voting as described in 'Object detection via a multi-region &
semantic segmentation-aware CNN model', Gidaris and Komodakis, ICCV 2015. For
each box 'B' in selected_boxes, we find the set 'S' of boxes in pool_boxes
with iou overlap >= iou_thresh. The location of B is set to the weighted
average location of boxes in S (scores are used for weighting). And the score
of B is set to the average score of boxes in S.
Args:
selected_boxes: BoxList containing a subset of boxes in pool_boxes. These
boxes are usually selected from pool_boxes using non max suppression.
pool_boxes: BoxList containing a set of (possibly redundant) boxes.
iou_thresh: (float scalar) iou threshold for matching boxes in
selected_boxes and pool_boxes.
Returns:
BoxList containing averaged locations and scores for each box in
selected_boxes.
Raises:
ValueError: if
a) selected_boxes or pool_boxes is not a BoxList.
b) if iou_thresh is not in [0, 1].
c) pool_boxes does not have a scores field.
"""
if not 0.0 <= iou_thresh <= 1.0:
raise ValueError('iou_thresh must be between 0 and 1')
if not isinstance(selected_boxes, box_list.BoxList):
raise ValueError('selected_boxes must be a BoxList')
if not isinstance(pool_boxes, box_list.BoxList):
raise ValueError('pool_boxes must be a BoxList')
if not pool_boxes.has_field('scores'):
raise ValueError('pool_boxes must have a \'scores\' field')
iou_ = iou(selected_boxes, pool_boxes)
match_indicator = tf.to_float(tf.greater(iou_, iou_thresh))
num_matches = tf.reduce_sum(match_indicator, 1)
# TODO: Handle the case where some boxes in selected_boxes do not
# match to any boxes in pool_boxes. For such boxes without any matches, we
# should return the original boxes without voting.
match_assert = tf.Assert(tf.reduce_all(tf.greater(num_matches, 0)), [
'Each box in selected_boxes must match with at least one box '
'in pool_boxes.'
])
scores = tf.expand_dims(pool_boxes.get_field('scores'), 1)
scores_assert = tf.Assert(tf.reduce_all(tf.greater_equal(scores, 0)),
['Scores must be non negative.'])
with tf.control_dependencies([scores_assert, match_assert]):
sum_scores = tf.matmul(match_indicator, scores)
averaged_scores = tf.reshape(sum_scores, [-1]) / num_matches
box_locations = tf.matmul(match_indicator,
pool_boxes.get() * scores) / sum_scores
averaged_boxes = box_list.BoxList(box_locations)
_copy_extra_fields(averaged_boxes, selected_boxes)
averaged_boxes.add_field('scores', averaged_scores)
return averaged_boxes
pdepth = proj_depth_p
prgb = tf.to_float(proj_rgb_p)
psift = tf.to_float(proj_sift_p)
keep = prm.pct_3D_points / 100.
pdepth = tf.nn.dropout(
pdepth, keep, noise_shape=[1, prm.crop_size, prm.crop_size, 1
], seed=0) * keep
prgb = tf.nn.dropout(
prgb, keep, noise_shape=[1, prm.crop_size, prm.crop_size, 1
], seed=0) * keep
psift = tf.nn.dropout(
psift, keep, noise_shape=[1, prm.crop_size, prm.crop_size, 1
], seed=0) * keep
valid = tf.greater(pdepth, 0.)
# set up visibnet
if prm.input_attr == 'depth':
vinp = pdepth
elif prm.input_attr == 'depth_rgb':
vinp = tf.concat((pdepth, prgb / 127.5 - 1.), axis=3)
elif prm.input_attr == 'depth_sift':
vinp = tf.concat((pdepth, psift / 127.5 - 1.), axis=3)
elif prm.input_attr == 'depth_sift_rgb':
vinp = tf.concat((pdepth, psift / 127.5 - 1., prgb / 127.5 - 1.), axis=3)
vnet = VisibNet(vinp, bn='test')
vpred = tf.logical_and(tf.greater(vnet.pred, .5), valid)
vpredf = tf.to_float(vpred) * 0. + 1.
# set up coarsenet
def main():
args = parser.parse_args()
# Data augmentation
global seq_geo
global seq_img
seq_geo = iaa.SomeOf(
(0, 5),
[
iaa.Fliplr(0.5), # horizontally flip 50% of the images
iaa.PerspectiveTransform(scale=(0, 0.075)),
iaa.Affine(
scale={
"x": (0.8, 1.0),
"y": (0.8, 1.0)
},
rotate=(-5, 5),
translate_percent={
"x": (-0.1, 0.1),
"y": (-0.1, 0.1)
},
), # rotate by -45 to +45 degrees),
iaa.Crop(percent=(
0, 0.125
)), # crop images from each side by 0 to 12.5% (randomly chosen)
iaa.CoarsePepper(p=0.01, size_percent=0.1)
],
random_order=False)
# Content transformation
seq_img = iaa.SomeOf(
(0, 3),
[
iaa.GaussianBlur(
sigma=(0, 1.0)), # blur images with a sigma of 0 to 2.0
iaa.ContrastNormalization(alpha=(0.9, 1.1)),
iaa.Grayscale(alpha=(0, 0.2)),
iaa.Multiply((0.9, 1.1))
])
# We store all arguments in a json file. This has two advantages:
# 1. We can always get back and see what exactly that experiment was
# 2. We can resume an experiment as-is without needing to remember all flags.
args_file = os.path.join(args.experiment_root, 'args.json')
if args.resume:
if not os.path.isfile(args_file):
raise IOError('`args.json` not found in {}'.format(args_file))
print('Loading args from {}.'.format(args_file))
with open(args_file, 'r') as f:
args_resumed = json.load(f)
args_resumed['resume'] = True # This would be overwritten.
# When resuming, we not only want to populate the args object with the
# values from the file, but we also want to check for some possible
# conflicts between loaded and given arguments.
for key, value in args.__dict__.items():
if key in args_resumed:
resumed_value = args_resumed[key]
if resumed_value != value:
print('Warning: For the argument `{}` we are using the'
' loaded value `{}`. The provided value was `{}`'
'.'.format(key, resumed_value, value))
args.__dict__[key] = resumed_value
else:
print('Warning: A new argument was added since the last run:'
' `{}`. Using the new value: `{}`.'.format(key, value))
else:
# If the experiment directory exists already, we bail in fear.
if os.path.exists(args.experiment_root):
if os.listdir(args.experiment_root):
print('The directory {} already exists and is not empty.'
' If you want to resume training, append --resume to'
' your call.'.format(args.experiment_root))
exit(1)
else:
os.makedirs(args.experiment_root)
# Store the passed arguments for later resuming and grepping in a nice
# and readable format.
with open(args_file, 'w') as f:
json.dump(vars(args),
f,
ensure_ascii=False,
indent=2,
sort_keys=True)
log_file = os.path.join(args.experiment_root, "train")
logging.config.dictConfig(common.get_logging_dict(log_file))
log = logging.getLogger('train')
# Also show all parameter values at the start, for ease of reading logs.
log.info('Training using the following parameters:')
for key, value in sorted(vars(args).items()):
log.info('{}: {}'.format(key, value))
# Check them here, so they are not required when --resume-ing.
if not args.train_set:
parser.print_help()
log.error("You did not specify the `train_set` argument!")
sys.exit(1)
if not args.image_root:
parser.print_help()
log.error("You did not specify the required `image_root` argument!")
sys.exit(1)
# Load the data from the CSV file.
pids, fids = common.load_dataset(args.train_set, args.image_root)
max_fid_len = max(map(len, fids)) # We'll need this later for logfiles.
# Load feature embeddings
if args.hard_pool_size > 0:
with h5py.File(args.train_embeddings, 'r') as f_train:
train_embs = np.array(f_train['emb'])
f_dists = scipy.spatial.distance.cdist(train_embs, train_embs)
hard_ids = get_hard_id_pool(pids, f_dists, args.hard_pool_size)
# Setup a tf.Dataset where one "epoch" loops over all PIDS.
# PIDS are shuffled after every epoch and continue indefinitely.
unique_pids = np.unique(pids)
dataset = tf.data.Dataset.from_tensor_slices(unique_pids)
dataset = dataset.shuffle(len(unique_pids))
# Constrain the dataset size to a multiple of the batch-size, so that
# we don't get overlap at the end of each epoch.
if args.hard_pool_size == 0:
dataset = dataset.take(
(len(unique_pids) // args.batch_p) * args.batch_p)
dataset = dataset.repeat(
None) # Repeat forever. Funny way of stating it.
else:
dataset = dataset.repeat(
None) # Repeat forever. Funny way of stating it.
dataset = dataset.map(lambda pid: sample_batch_ids_for_pid(
pid, all_pids=pids, batch_p=args.batch_p, all_hard_pids=hard_ids))
# Unbatch the P PIDs
dataset = dataset.apply(tf.contrib.data.unbatch())
# For every PID, get K images.
dataset = dataset.map(lambda pid: sample_k_fids_for_pid(
pid, all_fids=fids, all_pids=pids, batch_k=args.batch_k))
# Ungroup/flatten the batches for easy loading of the files.
dataset = dataset.apply(tf.contrib.data.unbatch())
# Convert filenames to actual image tensors.
net_input_size = (args.net_input_height, args.net_input_width)
pre_crop_size = (args.pre_crop_height, args.pre_crop_width)
dataset = dataset.map(lambda fid, pid: common.fid_to_image(
fid,
pid,
image_root=args.image_root,
image_size=pre_crop_size if args.crop_augment else net_input_size),
num_parallel_calls=args.loading_threads)
# Augment the data if specified by the arguments.
if args.augment == False:
dataset = dataset.map(
lambda im, fid, pid: common.fid_to_image(
fid,
pid,
image_root=args.image_root,
image_size=pre_crop_size
if args.crop_augment else net_input_size), #Ergys
num_parallel_calls=args.loading_threads)
if args.flip_augment:
dataset = dataset.map(lambda im, fid, pid: (
tf.image.random_flip_left_right(im), fid, pid))
if args.crop_augment:
dataset = dataset.map(lambda im, fid, pid: (tf.random_crop(
im, net_input_size + (3, )), fid, pid))
else:
dataset = dataset.map(lambda im, fid, pid: common.fid_to_image(
fid, pid, image_root=args.image_root, image_size=net_input_size),
num_parallel_calls=args.loading_threads)
dataset = dataset.map(lambda im, fid, pid: (tf.py_func(
augment_images, [im], [tf.float32]), fid, pid))
dataset = dataset.map(lambda im, fid, pid: (tf.reshape(
im[0],
(args.net_input_height, args.net_input_width, 3)), fid, pid))
# Group it back into PK batches.
batch_size = args.batch_p * args.batch_k
dataset = dataset.batch(batch_size)
# Overlap producing and consuming for parallelism.
dataset = dataset.prefetch(batch_size * 2)
# Since we repeat the data infinitely, we only need a one-shot iterator.
images, fids, pids = dataset.make_one_shot_iterator().get_next()
# Create the model and an embedding head.
model = import_module('nets.' + args.model_name)
head = import_module('heads.' + args.head_name)
# Feed the image through the model. The returned `body_prefix` will be used
# further down to load the pre-trained weights for all variables with this
# prefix.
endpoints, body_prefix = model.endpoints(images, is_training=True)
with tf.name_scope('head'):
endpoints = head.head(endpoints, args.embedding_dim, is_training=True)
# Create the loss in two steps:
# 1. Compute all pairwise distances according to the specified metric.
# 2. For each anchor along the first dimension, compute its loss.
dists = loss.cdist(endpoints['emb'], endpoints['emb'], metric=args.metric)
losses, train_top1, prec_at_k, _, neg_dists, pos_dists = loss.LOSS_CHOICES[
args.loss](dists,
pids,
args.margin,
batch_precision_at_k=args.batch_k - 1)
# Count the number of active entries, and compute the total batch loss.
num_active = tf.reduce_sum(tf.cast(tf.greater(losses, 1e-5), tf.float32))
loss_mean = tf.reduce_mean(losses)
# Some logging for tensorboard.
tf.summary.histogram('loss_distribution', losses)
tf.summary.scalar('loss', loss_mean)
tf.summary.scalar('batch_top1', train_top1)
tf.summary.scalar('batch_prec_at_{}'.format(args.batch_k - 1), prec_at_k)
tf.summary.scalar('active_count', num_active)
tf.summary.histogram('embedding_dists', dists)
tf.summary.histogram('embedding_pos_dists', pos_dists)
tf.summary.histogram('embedding_neg_dists', neg_dists)
tf.summary.histogram('embedding_lengths',
tf.norm(endpoints['emb_raw'], axis=1))
# Create the mem-mapped arrays in which we'll log all training detail in
# addition to tensorboard, because tensorboard is annoying for detailed
# inspection and actually discards data in histogram summaries.
if args.detailed_logs:
log_embs = lb.create_or_resize_dat(
os.path.join(args.experiment_root, 'embeddings'),
dtype=np.float32,
shape=(args.train_iterations, batch_size, args.embedding_dim))
log_loss = lb.create_or_resize_dat(
os.path.join(args.experiment_root, 'losses'),
dtype=np.float32,
shape=(args.train_iterations, batch_size))
log_fids = lb.create_or_resize_dat(
os.path.join(args.experiment_root, 'fids'),
dtype='S' + str(max_fid_len),
shape=(args.train_iterations, batch_size))
# These are collected here before we add the optimizer, because depending
# on the optimizer, it might add extra slots, which are also global
# variables, with the exact same prefix.
model_variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
body_prefix)
# Define the optimizer and the learning-rate schedule.
# Unfortunately, we get NaNs if we don't handle no-decay separately.
# modified by ha (default decay rate 0.001)
global_step = tf.Variable(0, name='global_step', trainable=False)
if 0 <= args.decay_start_iteration < args.train_iterations:
learning_rate = tf.train.exponential_decay(
args.learning_rate,
tf.maximum(0, global_step - args.decay_start_iteration),
args.train_iterations - args.decay_start_iteration, 0.001)
else:
learning_rate = args.learning_rate
tf.summary.scalar('learning_rate', learning_rate)
optimizer = tf.train.AdamOptimizer(learning_rate)
# Feel free to try others!
# optimizer = tf.train.AdadeltaOptimizer(learning_rate)
# Update_ops are used to update batchnorm stats.
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
train_op = optimizer.minimize(loss_mean, global_step=global_step)
# Define a saver for the complete model.
checkpoint_saver = tf.train.Saver(max_to_keep=0)
with tf.Session() as sess:
if args.resume:
# In case we're resuming, simply load the full checkpoint to init.
last_checkpoint = tf.train.latest_checkpoint(args.experiment_root)
log.info('Restoring from checkpoint: {}'.format(last_checkpoint))
checkpoint_saver.restore(sess, last_checkpoint)
else:
# But if we're starting from scratch, we may need to load some
# variables from the pre-trained weights, and random init others.
sess.run(tf.global_variables_initializer())
if args.initial_checkpoint is not None:
# saver = tf.train.Saver(model_variables)
saver = tf.train.import_meta_graph(
'./mobilenet/mobilenet_v2_1.4_224.ckpt.meta')
saver.restore(sess, args.initial_checkpoint)
# In any case, we also store this initialization as a checkpoint,
# such that we could run exactly reproduceable experiments.
checkpoint_saver.save(sess,
os.path.join(args.experiment_root,
'checkpoint'),
global_step=0)
merged_summary = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(args.experiment_root,
sess.graph)
start_step = sess.run(global_step)
log.info('Starting training from iteration {}.'.format(start_step))
# Finally, here comes the main-loop. This `Uninterrupt` is a handy
# utility such that an iteration still finishes on Ctrl+C and we can
# stop the training cleanly.
with lb.Uninterrupt(sigs=[SIGINT, SIGTERM], verbose=True) as u:
for i in range(start_step, args.train_iterations):
# Compute gradients, update weights, store logs!
start_time = time.time()
_, summary, step, b_prec_at_k, b_embs, b_loss, b_fids = \
sess.run([train_op, merged_summary, global_step,
prec_at_k, endpoints['emb'], losses, fids])
elapsed_time = time.time() - start_time
# Compute the iteration speed and add it to the summary.
# We did observe some weird spikes that we couldn't track down.
summary2 = tf.Summary()
summary2.value.add(tag='secs_per_iter',
simple_value=elapsed_time)
summary_writer.add_summary(summary2, step)
summary_writer.add_summary(summary, step)
if args.detailed_logs:
log_embs[i], log_loss[i], log_fids[
i] = b_embs, b_loss, b_fids
# Do a huge print out of the current progress.
seconds_todo = (args.train_iterations - step) * elapsed_time
log.info(
'iter:{:6d}, loss min|avg|max: {:.3f}|{:.3f}|{:6.3f}, '
'batch-p@{}: {:.2%}, ETA: {} ({:.2f}s/it)'.format(
step, float(np.min(b_loss)), float(np.mean(b_loss)),
float(np.max(b_loss)), args.batch_k - 1,
float(b_prec_at_k),
timedelta(seconds=int(seconds_todo)), elapsed_time))
sys.stdout.flush()
sys.stderr.flush()
# Save a checkpoint of training every so often.
if (args.checkpoint_frequency > 0
and step % args.checkpoint_frequency == 0):
checkpoint_saver.save(sess,
os.path.join(args.experiment_root,
'checkpoint'),
global_step=step)
# Stop the main-loop at the end of the step, if requested.
if u.interrupted:
log.info("Interrupted on request!")
break
# Store one final checkpoint. This might be redundant, but it is crucial
# in case intermediate storing was disabled and it saves a checkpoint
# when the process was interrupted.
checkpoint_saver.save(sess,
os.path.join(args.experiment_root, 'checkpoint'),
global_step=step)
import numpy as np
import matplotlib.pyplot as plt
from numpy.random import RandomState
batch_size = 8
x = tf.placeholder(tf.float32, shape=(None, 2), name="x-input")
y_ = tf.placeholder(tf.float32, shape=(None, 1), name="y-input")
w1 = tf.Variable(tf.random_normal([2, 1],stddev=1, seed=1))
y = tf.matmul(x, w1)
loss_less = 10
loss_more = 1
loss = tf.reduce_sum(tf.where(tf.greater(y, y_), loss_more*(y-y_), loss_less*(y_-y)))
train_step = tf.train.AdamOptimizer(0.001).minimize(loss)
rdm = RandomState(1)
dataset_size = 128
X = rdm.rand(dataset_size, 2)
Y = [[x1 + x2 + rdm.rand()/10.0 -0.05] for (x1, x2) in X]
xx = np.zeros([91], dtype=float)
yy = np.ones([91], dtype=float)
with tf.Session() as sess:
init_op = tf.initialize_all_variables()
sess.run(init_op)
STEP = 9000
for i in range(STEP):
def forward(self, logits, targets, target_mask, training):
with tf.name_scope(self.name, values=[logits, targets, target_mask]):
# Get smoothing parameters (no smoothing/ normalization at test time)
high_confidence, low_confidence, normalizing_factor = \
tf.cond(tf.logical_and(training, tf.greater(self.label_smoothing_discount, 0.0)),
self._get_smoothing_parameters,
lambda: (1.0, 0.0, 0.0))
# If necessary, pad the label and the label-mask to match the length of decoder output
# Not sure if that's a sensible thing to do
targets_shape = tf.shape(targets)
logits_shape = tf.shape(logits)
targets_length = targets_shape[self.time_dim]
logits_length = logits_shape[self.time_dim]
def _get_pad_shape(shape_to_pad, shape_to_match):
""" Calculates the shape of the padding to be applied to the logits or targets. """
time_steps_to_pad = shape_to_match[
self.time_dim] - shape_to_pad[self.time_dim]
if self.time_dim == 0:
pad_shape = [time_steps_to_pad, shape_to_pad[1]]
else:
pad_shape = [shape_to_pad[0], time_steps_to_pad]
return pad_shape
def _pad_targets(targets, target_mask, logits):
""" Pads the targets to match the size of the model-generated logits. """
pad_shape = _get_pad_shape(targets_shape, logits_shape)
targets = tf.concat(
[targets,
tf.zeros(pad_shape, dtype=self.int_dtype)],
axis=self.time_dim)
target_mask = tf.concat(
[target_mask,
tf.zeros(pad_shape, dtype=self.float_dtype)],
axis=self.time_dim)
return targets, target_mask, logits
def _pad_logits(targets, target_mask, logits):
""" Pads the logits to match the size of the ground-truth targets. """
pad_shape = _get_pad_shape(logits_shape, targets_shape)
logits = tf.concat([
logits,
tf.zeros(pad_shape + [logits_shape[-1]],
dtype=self.float_dtype)
],
axis=self.time_dim)
return targets, target_mask, logits
# For teacher-forcing with RNN models
targets, target_mask, logits = tf.cond(
tf.equal(targets_length, logits_length), lambda:
(targets, target_mask, logits), lambda: tf.cond(
tf.less(targets_length, logits_length), lambda:
_pad_targets(targets, target_mask, logits), lambda:
_pad_logits(targets, target_mask, logits)))
# Project and optionally smooth target token ids
projected_targets = tf.one_hot(targets,
depth=self.vocab_size,
on_value=high_confidence,
off_value=low_confidence,
dtype=self.float_dtype)
# Compute token-level loss
flat_logits = tf.reshape(logits, [-1, self.vocab_size])
flat_targets = tf.reshape(projected_targets, [-1, self.vocab_size])
flat_loss = tf.nn.softmax_cross_entropy_with_logits_v2(
logits=flat_logits, labels=flat_targets)
flat_normalized_loss = flat_loss - normalizing_factor
# Compute sentence- and batch-level losses (i.e. mean token-loss per sentence/ batch)
normalized_loss = tf.reshape(flat_normalized_loss,
tf.shape(targets))
masked_loss = normalized_loss * target_mask
sentence_lengths = tf.reduce_sum(target_mask,
axis=self.time_dim,
keepdims=False)
sentence_loss = tf.div(
tf.reduce_sum(masked_loss, axis=self.time_dim, keepdims=False),
sentence_lengths)
batch_loss = tf.reduce_mean(sentence_loss, keepdims=False)
return masked_loss, sentence_loss, batch_loss
def setup_model(self):
print("setup_model : ppo_imitation.py -> PPOImitation.setup_model()")
traceback.print_stack()
with SetVerbosity(self.verbose):
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
# Construct network for new policy
self.policy_pi = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
None, reuse=False, **self.policy_kwargs)
# Network for old policy
with tf.variable_scope("oldpi", reuse=False):
old_pi = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
None, reuse=False, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
# Target advantage function (if applicable)
atarg = tf.placeholder(dtype=tf.float32, shape=[None])
# Empirical return
ret = tf.placeholder(dtype=tf.float32, shape=[None])
# learning rate multiplier, updated with schedule
lrmult = tf.placeholder(name='lrmult', dtype=tf.float32, shape=[])
# Annealed cliping parameter epislon
clip_param = self.clip_param * lrmult
obs_ph = self.policy_pi.obs_ph
action_ph = self.policy_pi.pdtype.sample_placeholder([None])
kloldnew = old_pi.proba_distribution.kl(self.policy_pi.proba_distribution)
ent = self.policy_pi.proba_distribution.entropy()
meankl = tf.reduce_mean(kloldnew)
meanent = tf.reduce_mean(ent)
pol_entpen = (-self.entcoeff) * meanent
# pnew / pold
ratio = tf.exp(self.policy_pi.proba_distribution.logp(action_ph) -
old_pi.proba_distribution.logp(action_ph))
# surrogate from conservative policy iteration
surr1 = ratio * atarg
surr2 = tf.clip_by_value(ratio, 1.0 - clip_param, 1.0 + clip_param) * atarg
clip_frac = tf.reduce_mean(tf.to_float(tf.greater(tf.abs(ratio - 1.0), clip_param)))
# PPO's pessimistic surrogate (L^CLIP)
pol_surr = - tf.reduce_mean(tf.minimum(surr1, surr2))
vf_loss = tf.reduce_mean(tf.square(self.policy_pi.value_flat - ret))
total_loss = pol_surr + pol_entpen + vf_loss
losses = [pol_surr, pol_entpen, vf_loss, meankl, meanent]
self.loss_names = ["pol_surr", "pol_entpen", "vf_loss", "kl", "ent"]
tf.summary.scalar('entropy_loss', pol_entpen)
tf.summary.scalar('policy_gradient_loss', pol_surr)
tf.summary.scalar('value_function_loss', vf_loss)
tf.summary.scalar('approximate_kullback-leibler', meankl)
tf.summary.scalar('clip_factor', clip_param)
tf.summary.scalar('loss', total_loss)
tf.summary.scalar('clip_frac', clip_frac)
self.params = tf_util.get_trainable_vars("model")
self.assign_old_eq_new = tf_util.function(
[], [], updates=[tf.assign(oldv, newv) for (oldv, newv) in
zipsame(tf_util.get_globals_vars("oldpi"), tf_util.get_globals_vars("model"))])
with tf.variable_scope("Adam_mpi", reuse=False):
self.adam = MpiAdam(self.params, epsilon=self.adam_epsilon, sess=self.sess)
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(ret))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.optim_stepsize))
tf.summary.scalar('advantage', tf.reduce_mean(atarg))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_param))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', ret)
tf.summary.histogram('learning_rate', self.optim_stepsize)
tf.summary.histogram('advantage', atarg)
tf.summary.histogram('clip_range', self.clip_param)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', obs_ph)
else:
tf.summary.histogram('observation', obs_ph)
self.step = self.policy_pi.step
self.proba_step = self.policy_pi.proba_step
self.initial_state = self.policy_pi.initial_state
tf_util.initialize(sess=self.sess)
self.summary = tf.summary.merge_all()
self.lossandgrad = tf_util.function([obs_ph, old_pi.obs_ph, action_ph, atarg, ret, lrmult],
[self.summary, tf_util.flatgrad(total_loss, self.params)] + losses)
self.compute_losses = tf_util.function([obs_ph, old_pi.obs_ph, action_ph, atarg, ret, lrmult],
losses)
return
mask_hard_pred = tf.argmax(
output, axis=3, name="mask_pred_class"
) # [batch_size, patch_size, patch_size] Each elt of the matrice (pixel) corresponds the predicted class 0, 1, .., or classes-1
mask_soft_pred_resh = tf.reshape(
output, [-1, classes]
) # [batch_size*patch_size*patch_size, classes] Each row (pixel) is the predicted logits for the pixel
else:
""" classes = 1 and We have binary segmentation
1. mask_hard_true: True mask hard coded with shape [batch_size, patch_size, patch_size]. The same as mask
a = [random.randint(0, 2) + random.random() for i in range(5)]
"""
# True labels
mask_hard_true = tf.cast(
tf.greater(mask, threshold), 'float'
) # [batch_size, patch_size, patch_size]. Each elt (pixel) of the matrice is 0 or 1, the class of the pixel
mask_hard_true_resh = tf.reshape(mask, [
-1
]) # [batch_size*patch_size*patch_size]. Each row is 0 or 1 for the pixel
# Predictions
mask_hard_pred = tf.cast(
tf.greater(output, threshold), 'float'
) # [batch_size, patch_size, patch_size] Each elt of the matrice (pixel) corresponds the predicted class 0 or 1
mask_soft_pred_resh = tf.reshape(
output, [-1]
) # [batch_size*patch_size*patch_size] Each elt of the vector (pixel) corresponds the calculated logit
# Loss
entropy_loss = cross_entropy_loss(mask_hard_true_resh, mask_soft_pred_resh,
image_pool_input = tf.placeholder(shape=[None, height, width, channel],
dtype=tf.float32,
name='image_pool_input')
u_thres = tf.placeholder(shape=[], dtype=tf.float32, name='u_thres')
l_thres = tf.placeholder(shape=[], dtype=tf.float32, name='l_thres')
lr = tf.placeholder(shape=[], dtype=tf.float32, name='learning_rate')
label_feat = ConvNetwork(image_pool_input,
num_cluster,
name='ConvNetwork',
reuse=False)
label_feat_norm = tf.nn.l2_normalize(label_feat, dim=1)
sim_mat = tf.matmul(label_feat_norm, label_feat_norm, transpose_b=True)
pos_loc = tf.greater(sim_mat, u_thres, name='greater')
neg_loc = tf.less(sim_mat, l_thres, name='less')
pos_loc_mask = tf.cast(pos_loc, dtype=tf.float32)
neg_loc_mask = tf.cast(neg_loc, dtype=tf.float32)
pred_label = tf.argmax(label_feat, axis=1)
# Deep Adaptive Image Clustering Cost Function Optimize
pos_entropy = tf.multiply(-tf.log(tf.clip_by_value(sim_mat, eps, 1.0)),
pos_loc_mask)
neg_entropy = tf.multiply(-tf.log(tf.clip_by_value(1 - sim_mat, eps, 1.0)),
neg_loc_mask)
loss_sum = tf.reduce_mean(pos_entropy) + tf.reduce_mean(neg_entropy)
train_op = tf.train.RMSPropOptimizer(lr).minimize(loss_sum)
Simple TensorFlow exercises
You should thoroughly test your code
"""
import tensorflow as tf
###############################################################################
# 1a: Create two random 0-d tensors x and y of any distribution.
# Create a TensorFlow object that returns x + y if x > y, and x - y otherwise.
# Hint: look up tf.cond()
# I do the first problem for you
###############################################################################
x = tf.random_uniform([]) # Empty array as shape creates a scalar.
y = tf.random_uniform([])
out = tf.cond(tf.greater(x, y), lambda: tf.add(x, y), lambda: tf.subtract(x, y))
###############################################################################
# 1b: Create two 0-d tensors x and y randomly selected from the range [-1, 1).
# Return x + y if x < y, x - y if x > y, 0 otherwise.
# Hint: Look up tf.case().
###############################################################################
x = tf.random_uniform([],-1,1,dtype=tf.float32)
y = tf.random_uniform([],-1,1,dtype=tf.float32)
out = tf.case({tf.less(x,y):lambda:tf.add(x,y),
tf.greater(x,y):lambda:tf.subtract(x,y),
default=lambda:tf.constant(0.0),exclusive=True})
###############################################################################
# 1c: Create the tensor x of the value [[0, -2, -1], [0, 1, 2]]
def _parse_train_data(self, data):
"""Parses data for training.
Args:
data: the decoded tensor dictionary from TfExampleDecoder.
Returns:
image: image tensor that is preproessed to have normalized value and
dimension [output_size[0], output_size[1], 3]
labels: a dictionary of tensors used for training. The following describes
{key: value} pairs in the dictionary.
image_info: a 2D `Tensor` that encodes the information of the image and
the applied preprocessing. It is in the format of
[[original_height, original_width], [scaled_height, scaled_width],
anchor_boxes: ordered dictionary with keys
[min_level, min_level+1, ..., max_level]. The values are tensor with
shape [height_l, width_l, 4] representing anchor boxes at each level.
rpn_score_targets: ordered dictionary with keys
[min_level, min_level+1, ..., max_level]. The values are tensor with
shape [height_l, width_l, anchors_per_location]. The height_l and
width_l represent the dimension of class logits at l-th level.
rpn_box_targets: ordered dictionary with keys
[min_level, min_level+1, ..., max_level]. The values are tensor with
shape [height_l, width_l, anchors_per_location * 4]. The height_l and
width_l represent the dimension of bounding box regression output at
l-th level.
gt_boxes: Groundtruth bounding box annotations. The box is represented
in [y1, x1, y2, x2] format. The coordinates are w.r.t the scaled
image that is fed to the network. The tennsor is padded with -1 to
the fixed dimension [self._max_num_instances, 4].
gt_classes: Groundtruth classes annotations. The tennsor is padded
with -1 to the fixed dimension [self._max_num_instances].
gt_masks: groundtrugh masks cropped by the bounding box and
resized to a fixed size determined by mask_crop_size.
"""
classes = data['groundtruth_classes']
boxes = data['groundtruth_boxes']
if self._include_mask:
masks = data['groundtruth_instance_masks']
is_crowds = data['groundtruth_is_crowd']
# Skips annotations with `is_crowd` = True.
if self._skip_crowd_during_training and self._is_training:
num_groundtruths = tf.shape(classes)[0]
with tf.control_dependencies([num_groundtruths, is_crowds]):
indices = tf.cond(
tf.greater(tf.size(is_crowds), 0),
lambda: tf.where(tf.logical_not(is_crowds))[:, 0],
lambda: tf.cast(tf.range(num_groundtruths), tf.int64))
classes = tf.gather(classes, indices)
boxes = tf.gather(boxes, indices)
if self._include_mask:
masks = tf.gather(masks, indices)
# Gets original image and its size.
image = data['image']
image_shape = tf.shape(image)[0:2]
# Normalizes image with mean and std pixel values.
image = input_utils.normalize_image(image)
# Flips image randomly during training.
if self._aug_rand_hflip:
if self._include_mask:
image, boxes, masks = input_utils.random_horizontal_flip(
image, boxes, masks)
else:
image, boxes = input_utils.random_horizontal_flip(image, boxes)
# Converts boxes from normalized coordinates to pixel coordinates.
# Now the coordinates of boxes are w.r.t. the original image.
boxes = box_utils.denormalize_boxes(boxes, image_shape)
# Resizes and crops image.
image, image_info = input_utils.resize_and_crop_image(
image,
self._output_size,
padded_size=input_utils.compute_padded_size(
self._output_size, 2**self._max_level),
aug_scale_min=self._aug_scale_min,
aug_scale_max=self._aug_scale_max)
image_height, image_width, _ = image.get_shape().as_list()
# Resizes and crops boxes.
# Now the coordinates of boxes are w.r.t the scaled image.
image_scale = image_info[2, :]
offset = image_info[3, :]
boxes = input_utils.resize_and_crop_boxes(boxes, image_scale,
image_info[1, :], offset)
# Filters out ground truth boxes that are all zeros.
indices = box_utils.get_non_empty_box_indices(boxes)
boxes = tf.gather(boxes, indices)
classes = tf.gather(classes, indices)
if self._include_mask:
masks = tf.gather(masks, indices)
# Transfer boxes to the original image space and do normalization.
cropped_boxes = boxes + tf.tile(tf.expand_dims(offset, axis=0),
[1, 2])
cropped_boxes /= tf.tile(tf.expand_dims(image_scale, axis=0),
[1, 2])
cropped_boxes = box_utils.normalize_boxes(cropped_boxes,
image_shape)
num_masks = tf.shape(masks)[0]
masks = tf.image.crop_and_resize(
tf.expand_dims(masks, axis=-1),
cropped_boxes,
box_indices=tf.range(num_masks, dtype=tf.int32),
crop_size=[self._mask_crop_size, self._mask_crop_size],
method='bilinear')
masks = tf.squeeze(masks, axis=-1)
# Class manipulation.
# Filter out novel split classes from training.
if self._train_class != 'all':
valid_classes = tf.cast(class_utils.coco_split_class_ids(
self._train_class),
dtype=classes.dtype)
match = tf.reduce_any(
tf.equal(tf.expand_dims(valid_classes, 1),
tf.expand_dims(classes, 0)), 0)
# kill novel split classes and boxes.
boxes = tf.gather(boxes, tf.where(match)[:, 0])
classes = tf.gather(classes, tf.where(match)[:, 0])
if self._include_mask:
masks = tf.gather(masks, tf.where(match)[:, 0])
# Assigns anchor targets.
# Note that after the target assignment, box targets are absolute pixel
# offsets w.r.t. the scaled image.
input_anchor = anchor.Anchor(self._min_level, self._max_level,
self._num_scales, self._aspect_ratios,
self._anchor_size,
(image_height, image_width))
anchor_labeler = anchor.OlnAnchorLabeler(
input_anchor,
self._rpn_match_threshold,
self._rpn_unmatched_threshold,
self._rpn_batch_size_per_im,
self._rpn_fg_fraction,
# for centerness target.
self._has_centerness,
self._rpn_center_match_iou_threshold,
self._rpn_center_unmatched_iou_threshold,
self._rpn_num_center_samples_per_im,
)
if self._has_centerness:
rpn_score_targets, _, rpn_lrtb_targets, rpn_center_targets = (
anchor_labeler.label_anchors_lrtb(gt_boxes=boxes,
gt_labels=tf.cast(
tf.expand_dims(classes,
axis=-1),
dtype=tf.float32)))
else:
rpn_score_targets, rpn_box_targets = anchor_labeler.label_anchors(
boxes,
tf.cast(tf.expand_dims(classes, axis=-1), dtype=tf.float32))
# For base rpn, dummy placeholder for centerness target.
rpn_center_targets = rpn_score_targets.copy()
# If bfloat16 is used, casts input image to tf.bfloat16.
if self._use_bfloat16:
image = tf.cast(image, dtype=tf.bfloat16)
inputs = {
'image': image,
'image_info': image_info,
}
# Packs labels for model_fn outputs.
labels = {
'anchor_boxes':
input_anchor.multilevel_boxes,
'image_info':
image_info,
'rpn_score_targets':
rpn_score_targets,
'rpn_box_targets':
(rpn_lrtb_targets if self._has_centerness else rpn_box_targets),
'rpn_center_targets':
rpn_center_targets,
}
# If class_agnostic, convert to binary classes.
if self._class_agnostic:
classes = tf.where(tf.greater(classes, 0), tf.ones_like(classes),
tf.zeros_like(classes))
inputs['gt_boxes'] = input_utils.pad_to_fixed_size(
boxes, self._max_num_instances, -1)
inputs['gt_classes'] = input_utils.pad_to_fixed_size(
classes, self._max_num_instances, -1)
if self._include_mask:
inputs['gt_masks'] = input_utils.pad_to_fixed_size(
masks, self._max_num_instances, -1)
return inputs, labels
COST = 1
PROFIT = 9
rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)
Y = [[x1+x2+(rdm.rand()/10.0-0.05)] for (x1, x2) in X]
#1定义神经网络的输入、参数和输出，定义前向传播过程。
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
w1= tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)
#2定义损失函数及反向传播方法。
# 定义损失函数使得预测少了的损失大，于是模型应该偏向多的方向预测。
loss = tf.reduce_sum(tf.where(tf.greater(y, y_), (y - y_)*COST, (y_ - y)*PROFIT))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
#3生成会话，训练STEPS轮。
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
STEPS = 3000
for i in range(STEPS):
start = (i*BATCH_SIZE) % 32
end = (i*BATCH_SIZE) % 32 + BATCH_SIZE
sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})
if i % 500 == 0:
print "After %d training steps, w1 is: " % (i)
print sess.run(w1), "\n"
print "Final w1 is: \n", sess.run(w1)
# print(tf.greater(v1, v2).eval())
# print(tf.where(tf.greater(v1, v2), v1, v2).eval())
# sess.close()
batch_size = 8
x = tf.placeholder(tf.float32, shape=(None, 2), name='x-input')
y_ = tf.placeholder(tf.float32, shape=(None, 1), name='y-input')
w1 = tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)
loss_less = 10
loss_more = 1
loss = tf.reduce_sum(
tf.where(tf.greater(y, y_), (y - y_) * loss_more, (y_ - y) * loss_less))
train_step = tf.train.AdamOptimizer(0.001).minimize(loss)
rdm = RandomState(1)
dataset_size = 128
X = rdm.rand(dataset_size, 2)
Y = [[x1 + x2 + rdm.rand() / 10.0 - 0.05] for (x1, x2) in X]
# 开始训练
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
STEPS = 5000
for i in range(STEPS):
start = (i * batch_size) % dataset_size
def top_k_top_p(
self,
tokenized_input_dict,
max_iterations,
top_k=0,
top_p=0,
temperature=1.0,
do_sample=True,
num_return_sequences=1,
eos_id=-100,
):
# We need this to return
input_ids_original = tokenized_input_dict["input_ids"]
batch_size = tf.shape(input_ids_original)[0]
max_sequence_length = tf.shape(input_ids_original)[1]
# Repeat for beam search
tokenized_input_dict_ragged = {}
for input_key, input_value in tokenized_input_dict.items():
tokenized_input_dict_ragged[input_key] = tf.repeat(
input_value, [num_return_sequences], axis=0)
# We take 2x beams
batch_size_updated = tokenized_input_dict_ragged["input_ids"].shape[0]
# Initialize with zeros
zero_entry = tf.zeros((
self.num_hidden_layers,
batch_size_updated,
self.num_attention_heads,
max_sequence_length,
self.attention_state,
))
all_cache_key = zero_entry
all_cache_value = zero_entry
past_length = tf.expand_dims(
tf.zeros(batch_size_updated, dtype=tf.int32), 0)
# Inputs ready
tokenized_input_dict_ragged["all_cache_key"] = all_cache_key
tokenized_input_dict_ragged["all_cache_value"] = all_cache_value
tokenized_input_dict_ragged["past_length"] = past_length
if self.input_type_ids > -1:
tokenized_input_dict_ragged["input_type_ids"] = (
tf.ones_like(tokenized_input_dict_ragged["input_ids"]) *
self.input_type_ids)
if self.input_mask_ids > -1:
tokenized_input_dict_ragged["input_mask"] = (
tf.ones_like(tokenized_input_dict_ragged["input_ids"]) *
self.input_mask_ids)
all_predictions = []
matched_positions = tf.constant([-1] * batch_size_updated)
# Iterate Over
for i in range(max_iterations):
result = self.model_fn(tokenized_input_dict_ragged)
model_logits = result["last_token_logits"]
all_cache_key = result["all_cache_key"]
all_cache_value = result["all_cache_value"]
past_length = result["past_length"]
if top_k > 0:
model_logits = top_k_logits(model_logits, k=top_k)
if top_p > 0:
model_logits = top_p_logits(model_logits, p=top_p)
if do_sample:
prediction_ids = tf.random.categorical(model_logits,
num_samples=1)
input_ids = tf.cast(prediction_ids, tf.int32)
else:
prediction_ids = tf.argmax(model_logits, axis=1)
input_ids = tf.cast(tf.expand_dims(prediction_ids, axis=1),
tf.int32)
all_predictions.append(input_ids)
if i == 0:
# all_cache_key = assign_zeros_to_K_V(all_cache_key, \
# input_ids_copy, batch_size, max_sequence_length)
# all_cache_value = assign_zeros_to_K_V(all_cache_value, \
# input_ids_copy, batch_size, max_sequence_length)
masks = tf.cast(
tf.not_equal(tokenized_input_dict_ragged["input_ids"], -1),
tf.float32,
)
masks = tf.reshape(
masks, (1, batch_size_updated, 1, max_sequence_length, 1))
all_cache_key = all_cache_key * masks
all_cache_value = all_cache_value * masks
tokenized_input_dict_ragged["input_ids"] = tf.cast(
input_ids, tf.int32)
tokenized_input_dict_ragged["all_cache_key"] = all_cache_key
tokenized_input_dict_ragged["all_cache_value"] = all_cache_value
tokenized_input_dict_ragged["past_length"] = past_length
if self.input_type_ids > -1:
tokenized_input_dict_ragged["input_type_ids"] = (
tf.ones_like(tokenized_input_dict_ragged["input_ids"]) *
self.input_type_ids)
if self.input_mask_ids > -1:
tokenized_input_dict_ragged["input_mask"] = (
tf.ones_like(tokenized_input_dict_ragged["input_ids"]) *
self.input_mask_ids)
if eos_id:
temp_m = tf.concat(all_predictions, axis=1)
eos_check = tf.greater(
tf.reduce_prod(
tf.reduce_sum(tf.cast(tf.equal(temp_m, eos_id),
tf.int32),
axis=[1])),
0,
)
if eos_check:
matched_positions = tf.argmax(tf.cast(
tf.equal(eos_id, temp_m), tf.int32),
axis=1)
# matched_positions += 1
break
matched_positions = (tf.reshape(
tf.argmax(
tf.cast(tf.equal(eos_id, tf.concat(all_predictions, axis=1)),
tf.int32),
axis=1,
),
-1,
) - 1)
# no eos matched positions will be 0, replace with -1
eos_pos_mask = tf.cast(tf.equal(matched_positions, 0), tf.int32) * -1
matched_positions = tf.cast(matched_positions, tf.int32) + eos_pos_mask
all_predictions = tf.reshape(tf.concat(all_predictions, axis=1),
(batch_size, num_return_sequences, -1))
return {
"iterations": i + 1,
"input_ids": input_ids_original,
"predicted_ids": all_predictions,
"matched_eos_pos": matched_positions,
}
def _parse_train_data(self, data):
"""Generates images and labels that are usable for model training.
Args:
data: a dict of Tensors produced by the decoder.
Returns:
images: the image tensor.
labels: a dict of Tensors that contains labels.
"""
shape = tf.shape(data['image'])
image = data['image'] / 255
boxes = data['groundtruth_boxes']
width = shape[0]
height = shape[1]
image, boxes = yolo_preprocess_ops.fit_preserve_aspect_ratio(
image,
boxes,
width=width,
height=height,
target_dim=self._max_process_size)
image_shape = tf.shape(image)[:2]
if self._random_flip:
image, boxes, _ = preprocess_ops.random_horizontal_flip(
image, boxes, seed=self._seed)
randscale = self._image_w // self._net_down_scale
if not self._fixed_size:
do_scale = tf.greater(
tf.random.uniform([], minval=0, maxval=1, seed=self._seed),
0.5)
if do_scale:
# This scales the image to a random multiple of net_down_scale
# between 320 to 608
randscale = tf.random.uniform(
[],
minval=self._min_process_size // self._net_down_scale,
maxval=self._max_process_size // self._net_down_scale,
seed=self._seed,
dtype=tf.int32) * self._net_down_scale
if self._jitter_boxes != 0.0:
boxes = box_ops.denormalize_boxes(boxes, image_shape)
boxes = box_ops.jitter_boxes(boxes, 0.025)
boxes = box_ops.normalize_boxes(boxes, image_shape)
# YOLO loss function uses x-center, y-center format
boxes = yolo_box_ops.yxyx_to_xcycwh(boxes)
if self._jitter_im != 0.0:
image, boxes = yolo_preprocess_ops.random_translate(
image, boxes, self._jitter_im, seed=self._seed)
if self._aug_rand_zoom:
image, boxes = yolo_preprocess_ops.resize_crop_filter(
image,
boxes,
default_width=self._image_w,
default_height=self._image_h,
target_width=randscale,
target_height=randscale)
image = tf.image.resize(image, (416, 416), preserve_aspect_ratio=False)
if self._aug_rand_brightness:
image = tf.image.random_brightness(image=image,
max_delta=.1) # Brightness
if self._aug_rand_saturation:
image = tf.image.random_saturation(image=image,
lower=0.75,
upper=1.25) # Saturation
if self._aug_rand_hue:
image = tf.image.random_hue(image=image, max_delta=.3) # Hue
image = tf.clip_by_value(image, 0.0, 1.0)
# Find the best anchor for the ground truth labels to maximize the iou
best_anchors = yolo_preprocess_ops.get_best_anchor(
boxes, self._anchors, width=self._image_w, height=self._image_h)
# Padding
boxes = preprocess_ops.clip_or_pad_to_fixed_size(
boxes, self._max_num_instances, 0)
classes = preprocess_ops.clip_or_pad_to_fixed_size(
data['groundtruth_classes'], self._max_num_instances, -1)
best_anchors = preprocess_ops.clip_or_pad_to_fixed_size(
best_anchors, self._max_num_instances, 0)
area = preprocess_ops.clip_or_pad_to_fixed_size(
data['groundtruth_area'], self._max_num_instances, 0)
is_crowd = preprocess_ops.clip_or_pad_to_fixed_size(
tf.cast(data['groundtruth_is_crowd'], tf.int32),
self._max_num_instances, 0)
labels = {
'source_id': data['source_id'],
'bbox': tf.cast(boxes, self._dtype),
'classes': tf.cast(classes, self._dtype),
'area': tf.cast(area, self._dtype),
'is_crowd': is_crowd,
'best_anchors': tf.cast(best_anchors, self._dtype),
'width': width,
'height': height,
'num_detections': tf.shape(data['groundtruth_classes'])[0],
}
if self._fixed_size:
grid = self._build_grid(labels,
self._image_w,
use_tie_breaker=self._use_tie_breaker)
labels.update({'grid_form': grid})
return image, labels
