def run_inference_for_single_image(image, graph):
with graph.as_default():
with tf.Session() as sess:
# 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]
if 'detection_masks' in output_dict:
output_dict['detection_masks'] = output_dict['detection_masks'][0]
return output_dict
def select_fg_for_masks(class_targets, box_targets, boxes,
proposal_to_label_map, max_num_fg=128):
"""Selects the fore ground objects for mask branch during training.
Args:
class_targets: a tensor of shape [batch_size, num_boxes] representing the
class label for each box.
box_targets: a tensor with a shape of [batch_size, num_boxes, 4]. The tensor
contains the ground truth pixel coordinates of the scaled images for each
roi.
boxes: A 3-D Tensor of shape [batch_size, num_boxes, 4]. Each row
represents a box with [y1, x1, y2, x2] in un-normalized coordinates.
proposal_to_label_map: a tensor with a shape of [batch_size, num_boxes].
This tensor keeps the mapping between proposal to labels.
proposal_to_label_map[i] means the index of the ground truth instance for
the i-th proposal.
max_num_fg: an integer represents the number of masks per image.
Returns:
class_targets, boxes, proposal_to_label_map, box_targets that have
foreground objects.
"""
with tf.name_scope('select_fg_for_masks'):
# Masks are for positive (fg) objects only. Reference: https://github.com/facebookresearch/Detectron/blob/master/detectron/roi_data/mask_rcnn.py # pylint: disable=line-too-long
batch_size = boxes.shape[0]
_, fg_indices = tf.nn.top_k(
tf.to_float(tf.greater(class_targets, 0)), k=max_num_fg)
# Contructs indices for gather.
indices = tf.reshape(
fg_indices + tf.expand_dims(
tf.range(batch_size) * tf.shape(class_targets)[1], 1), [-1])
fg_class_targets = tf.reshape(
tf.gather(tf.reshape(class_targets, [-1, 1]), indices),
[batch_size, -1])
fg_box_targets = tf.reshape(
tf.gather(tf.reshape(box_targets, [-1, 4]), indices),
[batch_size, -1, 4])
fg_box_rois = tf.reshape(
tf.gather(tf.reshape(boxes, [-1, 4]), indices), [batch_size, -1, 4])
fg_proposal_to_label_map = tf.reshape(
tf.gather(tf.reshape(proposal_to_label_map, [-1, 1]), indices),
[batch_size, -1])
return (fg_class_targets, fg_box_targets, fg_box_rois,
fg_proposal_to_label_map)
def _make_evaluation_metrics(labels, predictions, num_output_classes, hparams):
"""Construct various eval metrics.
Args:
labels: dict with ground truth data necessary for computing metrics.
predictions: dict containing Tensors for predictions.
num_output_classes: number of different labels.
hparams: tf.contrib.HParams object.
Returns:
A dict where the values obey the tf.metrics API.
"""
labels_op = labels[protein_dataset.LABEL_KEY]
multi_hot_labels = _indices_to_multihot(labels_op, num_output_classes)
predictions_as_floats = predictions[protein_dataset.LABEL_KEY]
recall_threshold = hparams.decision_threshold
predictions_as_bools = tf.greater(predictions_as_floats,
tf.constant(recall_threshold))
metrics = {
'precision_at_threshold':
tf.metrics.precision(labels=multi_hot_labels,
predictions=predictions_as_bools),
'recall_at_threshold':
tf.metrics.recall(labels=multi_hot_labels,
predictions=predictions_as_bools),
'f1_at_threshold':
_f1_score(labels=multi_hot_labels, predictions=predictions_as_bools),
'mean_examplewise_f1_at_threshold':
_mean_examplewise_f1_score(labels=multi_hot_labels,
predictions=predictions_as_bools),
'true_positives':
tf.metrics.true_positives(labels=multi_hot_labels,
predictions=predictions_as_bools),
'false_positives':
tf.metrics.false_positives(labels=multi_hot_labels,
predictions=predictions_as_bools)
}
for k in _THRESHOLDS_FOR_RECALL_METRIC:
metrics['recall@%d' % k] = _custom_recall_at_k(
labels_as_multi_hot=multi_hot_labels,
predictions=predictions_as_floats,
k=k)
return metrics
def random_horizontal_flip(image,
boxes=None,
masks=None,
keypoints=None,
keypoint_flip_permutation=None,
seed=None):
def _flip_image(image):
image_flipped = tf.image.flip_left_right(image)
return image_flipped
if keypoints is not None and keypoint_flip_permutation is None:
raise ValueError(
'keypoints are provided but keypoints_flip_permutation is not provided'
)
with tf.name_scope('RandomHorizontalFlip', values=[image, boxes]):
result = []
# random variable defining whether to do flip or not
do_a_flip_random = tf.greater(tf.random_uniform([], seed=seed), 0.5)
# flip image
image = tf.cond(do_a_flip_random, lambda: _flip_image(image),
lambda: image)
result.append(image)
# flip boxes
if boxes is not None:
boxes = tf.cond(do_a_flip_random,
lambda: _flip_boxes_left_right(boxes),
lambda: boxes)
result.append(boxes)
# flip masks
if masks is not None:
masks = tf.cond(do_a_flip_random,
lambda: _flip_masks_left_right(masks),
lambda: masks)
result.append(masks)
# flip keypoints
if keypoints is not None and keypoint_flip_permutation is not None:
permutation = keypoint_flip_permutation
keypoints = tf.cond(
do_a_flip_random,
lambda: keypoint_flip_horizontal(keypoints, 0.5, permutation),
lambda: keypoints)
result.append(keypoints)
return tuple(result)
def body(self, features):
self.has_actions = "input_action" in features
self.has_rewards = "target_reward" in features
self.has_policies = "target_policy" in features
self.has_values = "target_value" in features
hparams = self.hparams
def merge(inputs, targets):
"""Split inputs and targets into lists."""
inputs = tf.unstack(inputs, axis=1)
targets = tf.unstack(targets, axis=1)
assert len(inputs) == hparams.video_num_input_frames
assert len(targets) == hparams.video_num_target_frames
return inputs + targets
frames = merge(features["inputs"], features["targets"])
frames_raw = merge(features["inputs_raw"], features["targets_raw"])
actions, rewards = None, None
if self.has_actions:
actions = merge(features["input_action"],
features["target_action"])
if self.has_rewards:
rewards = merge(features["input_reward"],
features["target_reward"])
# Reset the internal states if the reset_internal_states has been
# passed as a feature and has greater value than 0.
if self.is_recurrent_model and self.internal_states is not None:
def reset_func():
reset_ops = flat_lists(self.reset_internal_states_ops())
with tf.control_dependencies(reset_ops):
return tf.no_op()
if self.is_predicting and "reset_internal_states" in features:
reset = features["reset_internal_states"]
reset = tf.greater(tf.reduce_sum(reset), 0.5)
reset_ops = tf.cond(reset, reset_func, tf.no_op)
else:
reset_ops = tf.no_op()
with tf.control_dependencies([reset_ops]):
frames[0] = tf.identity(frames[0])
with tf.control_dependencies([frames[0]]):
return self.__process(frames, actions, rewards, frames_raw)
def SingleImageDistortion(image):
# Adjust brightness to a random level.
if random_brightness:
delta = tf.random_uniform([], -max_delta_brightness,
max_delta_brightness)
image = tf.image.adjust_brightness(image, delta)
# Adjust saturation to a random level.
if random_saturation:
lower = lower_saturation
upper = upper_saturation
saturation_factor = tf.random_uniform([], lower, upper)
image = tf.image.adjust_saturation(image, saturation_factor)
# Randomly shift the hue.
if random_hue:
delta = tf.random_uniform([], -max_delta_hue, max_delta_hue)
image = tf.image.adjust_hue(image, delta)
# Adjust contrast to a random level.
if random_contrast:
lower = lower_contrast
upper = upper_contrast
contrast_factor = tf.random_uniform([], lower, upper)
image = tf.image.adjust_contrast(image, contrast_factor)
# Add random Gaussian noise.
if random_noise_level:
rnd_noise = tf.random_normal(tf.shape(image),
stddev=random_noise_level)
img_shape = tf.shape(image)
def ImageClosure(value):
return lambda: value
image = tf.cond(
tf.reduce_all(
tf.greater(tf.random.uniform([1]),
random_noise_apply_probability)),
ImageClosure(image), ImageClosure(image + rnd_noise))
image = tf.reshape(image, img_shape)
# Clip to valid range.
image = tf.clip_by_value(image, 0.0, 1.0)
return image
def _build_losses(self, json_data):
actor_weight_decay = 0 if (
self.ACTOR_WEIGHT_DECAY_KEY
not in json_data) else json_data[self.ACTOR_WEIGHT_DECAY_KEY]
critic_weight_decay = 0 if (
self.CRITIC_WEIGHT_DECAY_KEY
not in json_data) else json_data[self.CRITIC_WEIGHT_DECAY_KEY]
norm_val_diff = self.val_norm.normalize_tf(
self.tar_val_tf) - self.val_norm.normalize_tf(self.critic_tf)
self.critic_loss_tf = 0.5 * tf.reduce_mean(tf.square(norm_val_diff))
if (critic_weight_decay != 0):
self.critic_loss_tf += critic_weight_decay * self._weight_decay_loss(
'main/critic')
norm_tar_a_tf = self.a_norm.normalize_tf(self.a_tf)
self._norm_a_mean_tf = self.a_norm.normalize_tf(self.a_mean_tf)
self.logp_tf = TFUtil.calc_logp_gaussian(norm_tar_a_tf,
self._norm_a_mean_tf,
self.norm_a_std_tf)
ratio_tf = tf.exp(self.logp_tf - self.old_logp_tf)
actor_loss0 = self.adv_tf * ratio_tf
actor_loss1 = self.adv_tf * tf.clip_by_value(
ratio_tf, 1.0 - self.ratio_clip, 1 + self.ratio_clip)
self.actor_loss_tf = -tf.reduce_mean(
tf.minimum(actor_loss0, actor_loss1))
norm_a_bound_min = self.a_norm.normalize(self.a_bound_min)
norm_a_bound_max = self.a_norm.normalize(self.a_bound_max)
a_bound_loss = TFUtil.calc_bound_loss(self._norm_a_mean_tf,
norm_a_bound_min,
norm_a_bound_max)
self.actor_loss_tf += a_bound_loss
if (actor_weight_decay != 0):
self.actor_loss_tf += actor_weight_decay * self._weight_decay_loss(
'main/actor')
# for debugging
self.clip_frac_tf = tf.reduce_mean(
tf.to_float(tf.greater(tf.abs(ratio_tf - 1.0), self.ratio_clip)))
return
def body_fn(step, selected_indices):
cluster_mask = tf.equal(clusters, unique_clusters[step])
cluster_indices = tf.where(cluster_mask)[:, 0]
cluster_scores = tf.gather(scores, cluster_indices, axis=0)
selected_idx = tf.cond(
pred=tf.greater(size_per_cluster[step], 0),
true_fn=lambda: Sampler.select_indices(
size=size_per_cluster[step],
scores=cluster_scores,
indices=cluster_indices,
soft=soft,
),
false_fn=lambda: tf.constant([], dtype=tf.int32),
)
return [
tf.add(step, 1),
selected_indices.write(step, selected_idx)
]
def nucleus_sampling(self, logits):
"""Nucleus sampling."""
p = self.hparams.nucleus_sampling
tf.logging.info("Nucleus sampling top_p = {}".format(p))
sort_indices = tf.argsort(logits, axis=-1, direction="DESCENDING")
probs = tf.gather(tf.nn.softmax(logits), sort_indices, batch_dims=1)
cumprobs = tf.cumsum(probs, axis=-1, exclusive=True)
# The top 1 candidate always will not be masked.
# This way ensures at least 1 indices will be selected.
sort_mask = tf.cast(tf.greater(cumprobs, p), logits.dtype)
batch_indices = tf.tile(
tf.expand_dims(tf.range(logits.shape[0]), axis=-1),
[1, logits.shape[1]])
top_p_mask = tf.scatter_nd(
tf.stack([batch_indices, sort_indices], axis=-1), sort_mask,
logits.shape)
logits -= top_p_mask * logits.dtype.max
return logits
def _decode_masks(self, parsed_tensors):
"""Decode a set of PNG masks to the tf.float32 tensors."""
def _decode_png_mask(png_bytes):
mask = tf.squeeze(tf.io.decode_png(png_bytes,
channels=1,
dtype=tf.uint8),
axis=-1)
mask = tf.cast(mask, dtype=tf.float32)
mask.set_shape([None, None])
return mask
height = parsed_tensors['image/height']
width = parsed_tensors['image/width']
masks = parsed_tensors['image/object/mask']
return tf.cond(
tf.greater(tf.size(masks), 0),
lambda: tf.map_fn(_decode_png_mask, masks, dtype=tf.float32),
lambda: tf.zeros([0, height, width], dtype=tf.float32))
def visit(tuple_path, oneof):
"""Visit a OneOf node in `structure`."""
string_path = '/'.join(map(str, tuple_path))
num_choices = len(oneof.choices)
logits = tf.get_variable(
name='logits/' + string_path,
initializer=tf.initializers.zeros(),
shape=[num_choices],
dtype=tf.float32)
logits = logits / temperature
tag_name = '{:s}_{:d}'.format(oneof.tag, tag_counters[oneof.tag])
tag_counters[oneof.tag] += 1
dist_info['logits_by_path'][string_path] = logits
dist_info['logits_by_tag'][tag_name] = logits
dist = tfp.distributions.OneHotCategorical(
logits=logits, dtype=tf.float32)
entropies[tuple_path] = dist.entropy()
sample_mask = dist.sample()
sample_log_prob = dist.log_prob(sample_mask)
if oneof.tag == basic_specs.OP_TAG:
sample_mask, sample_log_prob = _replace_sample_with_probability(
sample_mask, sample_log_prob, increase_ops_probability,
tf.constant([1.0/num_choices]*num_choices, tf.float32))
elif oneof.tag == basic_specs.FILTERS_TAG:
# NOTE: While np.argmax() was originally designed to work with integer
# filter sizes, it will also work with any object type that supports
# "less than" and "greater than" operations.
sample_mask, sample_log_prob = _replace_sample_with_probability(
sample_mask, sample_log_prob, increase_filters_probability,
tf.one_hot(np.argmax(oneof.choices), len(oneof.choices)))
log_probs[tuple_path] = sample_log_prob
for i in range(len(oneof.choices)):
tuple_subpath = tuple_path + ('choices', i)
is_active[tuple_subpath] = tf.greater(tf.abs(sample_mask[i]), 1e-6)
return schema.OneOf(choices=oneof.choices,
tag=oneof.tag,
mask=sample_mask)
def pano_forwards_condition(trip):
"""Checks if a pano is in a forward condition."""
ref_pose = trip.pose[1, :, :]
pano_pose = trip.pose[3, :, :]
ref_twds = -1.0 * ref_pose[:, 2]
# make sure max_depth>forward motion>median_depth
t_vec = pano_pose[:, 3] - ref_pose[:, 3]
ref_depth = trip.depth[1, :, :, 0]
ref_depth = tf.where(tf.equal(ref_depth, 0.0),
tf.reduce_max(ref_depth) * tf.ones_like(ref_depth),
ref_depth)
max_depth = tf.reduce_max(ref_depth)
median_depth = tf.contrib.distributions.percentile(ref_depth, 0.5)
min_depth_cond = tf.greater(tf.reduce_sum(ref_twds * t_vec), median_depth)
max_depth_cond = tf.less(tf.reduce_sum(ref_twds * t_vec), max_depth)
return tf.logical_and(min_depth_cond, max_depth_cond)
def _fast_rcnn_box_loss(box_outputs, box_targets, class_targets, normalizer=1.0,
delta=1.):
"""Computes box regression loss."""
# delta is typically around the mean value of regression target.
# for instances, the regression targets of 512x512 input with 6 anchors on
# P2-P6 pyramid is about [0.1, 0.1, 0.2, 0.2].
with tf.name_scope('fast_rcnn_box_loss'):
mask = tf.tile(tf.expand_dims(tf.greater(class_targets, 0), axis=2),
[1, 1, 4])
# The loss is normalized by the sum of non-zero weights before additional
# normalizer provided by the function caller.
box_loss = tf.losses.huber_loss(
box_targets,
box_outputs,
weights=mask,
delta=delta,
reduction=tf.losses.Reduction.SUM_BY_NONZERO_WEIGHTS)
box_loss /= normalizer
return box_loss
def detectMinVal(input_mat, var, threshold=1e-6, name='', debug=False):
eigen_min = tf.reduce_min(input_mat)
eigen_max = tf.reduce_max(input_mat)
eigen_ratio = eigen_max / eigen_min
input_mat_clipped = clipoutNeg(input_mat, threshold)
if debug:
input_mat_clipped = tf.cond(
tf.logical_or(tf.greater(eigen_ratio, 0.),
tf.less(eigen_ratio,
-500)), lambda: input_mat_clipped,
lambda: tf.Print(input_mat_clipped, [
tf.convert_to_tensor('screwed ratio ' + name +
' eigen values!!!'),
tf.convert_to_tensor(var.name), eigen_min, eigen_max,
eigen_ratio
]))
return input_mat_clipped
def model_fn(features, labels, mode):
"""The model function for creating an Estimtator."""
del labels
input_count = tf.reduce_sum(
tf.to_int32(tf.greater(features["input_refs"][:, :, 1],
features["input_refs"][:, :, 0])))
tf.summary.scalar("input_count", input_count)
loss_dict, pred_dict, areas = seq2act_model.core_graph(
features, hparams, mode, compute_additional_loss_fn)
if mode == tf_estimator.ModeKeys.PREDICT:
pred_dict["sequences"] = decode_sequence(
features, areas, hparams, decode_length,
post_processing=FLAGS.post_processing)
return tf_estimator.EstimatorSpec(mode, predictions=pred_dict)
elif mode == tf_estimator.ModeKeys.EVAL:
metrics = {}
_eval(metrics, pred_dict, loss_dict, features,
areas, compute_seq_accuracy,
hparams,
metric_types=FLAGS.metric_types.split(","),
decode_length=decode_length)
if compute_additional_metric_fn:
compute_additional_metric_fn(metrics, pred_dict, features)
return tf_estimator.EstimatorSpec(
mode, loss=loss_dict["total_loss"], eval_metric_ops=metrics)
else:
assert mode == tf_estimator.ModeKeys.TRAIN
loss = loss_dict["total_loss"]
for loss_name in loss_dict:
if loss_name == "total_loss":
continue
if loss_name.endswith("losses"):
continue
tf.summary.scalar(loss_name, loss_dict[loss_name])
step_num = tf.to_float(tf.train.get_global_step())
schedule_string = hparams.learning_rate_schedule
names = schedule_string.split("*")
names = [name.strip() for name in names if name.strip()]
ret = tf.constant(1.0)
for name in names:
ret *= learning_rate.learning_rate_factor(name, step_num, hparams)
train_op = optimize.optimize(loss, ret, hparams)
return tf_estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)
def body_fn(size_left, cluster_counts_left, cluster_sizes):
# Determine available clusters.
cluster_mask = tf.greater(cluster_counts_left, 0)
available_clusters = tf.where(cluster_mask)[:, 0]
# Uniformly select clusters from available.
indices = tf.random.uniform(
dtype=tf.int32, shape=(size_left,), maxval=tf.size(available_clusters)
)
cluster_indices = tf.gather(available_clusters, indices, axis=0)
cluster_sizes = tf.tensor_scatter_nd_add(
cluster_sizes,
indices=tf.expand_dims(cluster_indices, -1),
updates=tf.ones_like(cluster_indices, dtype=tf.int32),
)
# Truncate cluster sizes as necessary.
cluster_sizes = tf.minimum(cluster_sizes, cluster_counts)
cluster_counts_left = cluster_counts - cluster_sizes
size_left = size - tf.reduce_sum(cluster_sizes)
return size_left, cluster_counts_left, cluster_sizes
def select_action_tf(belief, vector_set):
"""
Compute optimal action given a belief distribution
:param belief: dim(belief) == dim(AlphaVector)
:param vector_set
:return: optimal action, V(b)
"""
assert not len(vector_set) == 0
max_v = tf.constant([-np.inf], tf.float32)
best_action = tf.constant([-1])
for av in vector_set:
with tf.name_scope('V_b'):
v = tf.reduce_sum(tf.multiply(av.v, belief))
best_action = tf.cond(tf.greater(v, max_v)[0], lambda: tf.constant([av.action]),
lambda: best_action)
max_v = tf.maximum(v, max_v)
return best_action, max_v
def compute_normalization_binary_search(activations, t, num_iters=10):
"""Returns the normalization value for each example (t < 1.0).
Args:
activations: A multi-dimensional tensor with last dimension `num_classes`.
t: Temperature 2 (< 1.0 for finite support).
num_iters: Number of iterations to run the method.
Return: A tensor of same rank as activation with the last dimension being 1.
"""
mu = tf.reduce_max(activations, -1, keep_dims=True)
normalized_activations = activations - mu
shape_activations = tf.shape(activations)
effective_dim = tf.cast(
tf.reduce_sum(tf.cast(
tf.greater(normalized_activations, -1.0 / (1.0 - t)), tf.int32),
-1,
keep_dims=True), tf.float32)
shape_partition = tf.concat([shape_activations[:-1], [1]], 0)
lower = tf.zeros(shape_partition)
upper = -log_t(1.0 / effective_dim, t) * tf.ones(shape_partition)
def iter_condition(i, unused_lower, unused_upper):
return i < num_iters
def iter_body(i, lower, upper):
logt_partition = (upper + lower) / 2.0
sum_probs = tf.reduce_sum(exp_t(
normalized_activations - logt_partition, t),
-1,
keep_dims=True)
update = tf.cast(tf.less(sum_probs, 1.0), tf.float32)
lower = tf.reshape(lower * update + (1.0 - update) * logt_partition,
shape_partition)
upper = tf.reshape(upper * (1.0 - update) + update * logt_partition,
shape_partition)
return [i + 1, lower, upper]
_, lower, upper = tf.while_loop(iter_condition,
iter_body, [0, lower, upper],
maximum_iterations=num_iters)
logt_partition = (upper + lower) / 2.0
return logt_partition + mu
def preprocessing_fn(inputs):
"""tf.transform's callback function for preprocessing inputs.
Args:
inputs: map from feature keys to raw not-yet-transformed features.
Returns:
Map from string feature key to transformed feature operations.
"""
outputs = {}
for key in _DENSE_FLOAT_FEATURE_KEYS:
# Preserve this feature as a dense float, setting nan's to the mean.
outputs[_transformed_name(key)] = tft.scale_to_z_score(
_fill_in_missing(inputs[key]))
for key in _VOCAB_FEATURE_KEYS:
# Build a vocabulary for this feature.
outputs[_transformed_name(key)] = tft.compute_and_apply_vocabulary(
_fill_in_missing(inputs[key]),
top_k=_VOCAB_SIZE,
num_oov_buckets=_OOV_SIZE)
for key in _BUCKET_FEATURE_KEYS:
outputs[_transformed_name(key)] = tft.bucketize(
_fill_in_missing(inputs[key]),
_FEATURE_BUCKET_COUNT,
always_return_num_quantiles=False)
for key in _CATEGORICAL_FEATURE_KEYS:
outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])
# Was this passenger a big tipper?
taxi_fare = _fill_in_missing(inputs[_FARE_KEY])
tips = _fill_in_missing(inputs[_LABEL_KEY])
outputs[_transformed_name(_LABEL_KEY)] = tf.compat.v1.where(
tf.math.is_nan(taxi_fare),
tf.cast(tf.zeros_like(taxi_fare), tf.int64),
# Test if the tip was > 20% of the fare.
tf.cast(tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))),
tf.int64))
return outputs
def padded_one_hot_encoding(indices, depth, left_pad):
"""Returns a zero padded one-hot tensor.
This function converts a sparse representation of indices (e.g., [4]) to a
zero padded one-hot representation (e.g., [0, 0, 0, 0, 1] with depth = 4 and
left_pad = 1). If `indices` is empty, the result will simply be a tensor of
shape (0, depth + left_pad). If depth = 0, then this function just returns
`None`.
Args:
indices: an integer tensor of shape [num_indices].
depth: depth for the one-hot tensor (integer).
left_pad: number of zeros to left pad the one-hot tensor with (integer).
Returns:
padded_onehot: a tensor with shape (num_indices, depth + left_pad). Returns
`None` if the depth is zero.
Raises:
ValueError: if `indices` does not have rank 1 or if `left_pad` or `depth are
either negative or non-integers.
TODO(rathodv): add runtime checks for depth and indices.
"""
if depth < 0 or not isinstance(depth, six.integer_types):
raise ValueError('`depth` must be a non-negative integer.')
if left_pad < 0 or not isinstance(left_pad, six.integer_types):
raise ValueError('`left_pad` must be a non-negative integer.')
if depth == 0:
return None
rank = len(indices.get_shape().as_list())
if rank != 1:
raise ValueError('`indices` must have rank 1, but has rank=%s' % rank)
def one_hot_and_pad():
one_hot = tf.cast(tf.one_hot(tf.cast(indices, tf.int64), depth,
on_value=1, off_value=0), tf.float32)
return tf.pad(one_hot, [[0, 0], [left_pad, 0]], mode='CONSTANT')
result = tf.cond(tf.greater(tf.size(indices), 0), one_hot_and_pad,
lambda: tf.zeros((tf.size(indices), depth + left_pad)))
return tf.reshape(result, [-1, depth + left_pad])
def __call__(self, attribute_outputs, attribute_targets, select_class_targets):
with tf.name_scope('attributes_loss'):
batch_size, num_instances, num_attributes = attribute_outputs.get_shape().as_list()
weights = tf.tile(
tf.reshape(tf.greater(select_class_targets, 0), [batch_size, num_instances, 1]),
[1, 1, num_attributes])
if self._loss_type == 'sigmoid_cross_entropy':
loss = tf.losses.sigmoid_cross_entropy(attribute_targets, attribute_outputs, weights=weights,
reduction=tf.losses.Reduction.SUM_BY_NONZERO_WEIGHTS)
elif self._loss_type == 'focal':
losses = focal_loss_v2(attribute_outputs, attribute_targets, self._focal_loss_alpha, self._focal_loss_gamma,
1.0)
loss = tf.losses.compute_weighted_loss(losses, weights=weights,
reduction=tf.losses.Reduction.SUM_BY_NONZERO_WEIGHTS)
loss *= self._focal_loss_weight
else:
raise ValueError('Loss type "%s" is not implemented' % self._loss_type)
return loss
def maybe_add_noise(image, noise_shape, scale0, scale1,
image_noise_probability, image_noise_ratio):
"""Add noise at two scales."""
if image_noise_probability < 0.000001 or (image_noise_ratio < 0.000001):
return image
noise_list = []
for scale in [scale0, scale1]:
rand_image_noise_ratio = tf.random.uniform(shape=[],
minval=0.0,
maxval=image_noise_ratio)
noise_list.append(
_rand_noise(0.0, rand_image_noise_ratio, scale, noise_shape))
skip_noise = tf.greater(tf.random.uniform([]), image_noise_probability)
image = tf.cond(skip_noise, lambda: image, lambda: image + noise_list[0])
image = tf.cond(skip_noise, lambda: image, lambda: image + noise_list[1])
return image
def compute_weight_by_frequency(labels):
"""Computes weights to keep positive/negative labels in balance.
For instance if labels contains 1 positive out of 9 negative, the positive
one will have weight 0.9, while negative will have weight 0.1
Args:
labels: +1/-1 tensor of shape [..., num_channels]
Returns:
tensor of the same shape as labels.
"""
p = tf.greater(labels, 0)
pf = tf.to_float(p)
positives = tf.reduce_sum(pf, axis=-1, keepdims=True) + tf.zeros_like(pf)
negatives = tf.reduce_sum(1 - pf, axis=-1,
keepdims=True) + tf.zeros_like(pf)
total = positives + negatives
weights = tf.where(p, negatives / total, positives / total)
return weights
def process_obj_mask(obj_id):
"""Create a mask for obj_id, skipping the background mask."""
mask = tf.logical_and(
tf.equal(current_seg, obj_id), # pylint: disable=cell-var-from-loop
tf.not_equal(tf.cast(0, tf.uint8), obj_id))
# Leave out vert small masks, that are most often errors.
size = tf.reduce_sum(tf.to_int32(mask))
mask = tf.logical_and(mask,
tf.greater(size, MIN_OBJECT_AREA))
if not self.boxify:
return mask
# Complete the mask to its bounding box.
binary_obj_masks_y = tf.reduce_any(mask,
axis=1,
keepdims=True)
binary_obj_masks_x = tf.reduce_any(mask,
axis=0,
keepdims=True)
return tf.logical_and(binary_obj_masks_y,
binary_obj_masks_x)
def per_instance_loss(i, current_ta_term_0, current_ta_term_1,
current_ta_term_2):
# TODO: simplify condition, use instance_axis somehow
if data_format == 'channels_first':
target_instances_mask = tf.expand_dims(tf.equal(
instances[i, ...], 1),
axis=instance_axis)
other_instances_mask = tf.expand_dims(tf.equal(
instances[i, ...], 2),
axis=instance_axis)
else:
target_instances_mask = tf.expand_dims(tf.equal(
instances[..., i], 1),
axis=instance_axis)
other_instances_mask = tf.expand_dims(tf.equal(
instances[..., i], 2),
axis=instance_axis)
current_terms = tf.cond(
tf.greater(tf.count_nonzero(target_instances_mask),
0), lambda: cosine_embedding_single_instance_loss(
embeddings,
target_instances_mask,
other_instances_mask,
normalized_embeddings,
term_1_2_normalization=term_1_2_normalization,
term_0_squared=term_0_squared,
term_1_squared=term_1_squared,
return_h_norm=return_h_norm,
is_background=is_background,
data_format=data_format), lambda:
(tf.zeros([0], dtype=embeddings.dtype),
tf.zeros([0], dtype=embeddings.dtype)) if not return_h_norm else
(tf.zeros([0], dtype=embeddings.dtype),
tf.zeros([0], dtype=embeddings.dtype),
tf.zeros([embeddings.shape[0]], dtype=embeddings.dtype)))
current_ta_term_0 = current_ta_term_0.write(i, current_terms[0])
current_ta_term_1 = current_ta_term_1.write(i, current_terms[1])
if return_h_norm:
current_ta_term_2 = current_ta_term_2.write(i, current_terms[2])
return i + 1, current_ta_term_0, current_ta_term_1, current_ta_term_2
def _atan2(y, x):
""" My implementation of atan2 in tensorflow. Returns in -pi .. pi."""
tan = tf.atan(y / (x + 1e-8)) # this returns in -pi/2 .. pi/2
one_map = tf.ones_like(tan)
# correct quadrant error
correction = tf.where(tf.less(x + 1e-8, 0.0), 3.141592653589793 * one_map,
0.0 * one_map)
tan_c = tan + correction # this returns in -pi/2 .. 3pi/2
# bring to positive values
correction = tf.where(tf.less(tan_c, 0.0), 2 * 3.141592653589793 * one_map,
0.0 * one_map)
tan_zero_2pi = tan_c + correction # this returns in 0 .. 2pi
# make symmetric
correction = tf.where(tf.greater(tan_zero_2pi, 3.141592653589793),
-2 * 3.141592653589793 * one_map, 0.0 * one_map)
tan_final = tan_zero_2pi + correction # this returns in -pi .. pi
return tan_final
def intensity_shift(image, label, per_class_intensity_scale,
per_class_intensity_shift):
"""Perturb intensity in lesion and non-lesion regions."""
if per_class_intensity_scale < 0.000001 and (per_class_intensity_shift <
0.000001):
return image
# Randomly change (mostly increase) intensity of non-lesion region.
per_class_noise = _truncated_normal(per_class_intensity_shift,
per_class_intensity_scale)
image = image + per_class_noise * (
image * tf.cast(tf.greater(label, 1.5), tf.float32))
# Randomly change (mostly decrease) intensity of lesion region.
per_class_noise = _truncated_normal(-per_class_intensity_shift,
per_class_intensity_scale)
image = image + per_class_noise * (
image * tf.cast(tf.less(label, 1.5), tf.float32))
return image
def zero_out_clipped_grads(grad, x, clip_min, clip_max):
"""
Helper function to erase entries in the gradient where the update would be
clipped.
:param grad: The gradient
:param x: The current input
:param clip_min: Minimum input component value
:param clip_max: Maximum input component value
"""
signed_grad = tf.sign(grad)
# Find input components that lie at the boundary of the input range, and
# where the gradient points in the wrong direction.
clip_low = tf.logical_and(tf.less_equal(x, tf.cast(clip_min, x.dtype)),
tf.less(signed_grad, 0))
clip_high = tf.logical_and(tf.greater_equal(x, tf.cast(clip_max, x.dtype)),
tf.greater(signed_grad, 0))
clip = tf.logical_or(clip_low, clip_high)
grad = tf.where(clip, mul(grad, 0), grad)
return grad
def _to_bfloat16_unbiased(x, noise):
"""Convert a float32 to a bfloat16 using randomized roundoff.
Args:
x: A float32 Tensor.
noise: a float32 Tensor with values in [0, 1), broadcastable to tf.shape(x)
Returns:
A float32 Tensor.
"""
x_sign = tf.sign(x)
# Make sure x is positive. If it is zero, the two candidates are identical.
x = x * x_sign + 1e-30
cand1 = tf.to_bfloat16(x)
cand1_f = tf.to_float(cand1)
# This relies on the fact that for a positive bfloat16 b,
# b * 1.005 gives you the next higher bfloat16 and b*0.995 gives you the
# next lower one. Both 1.005 and 0.995 are ballpark estimation.
cand2 = tf.to_bfloat16(
tf.where(tf.greater(x, cand1_f), cand1_f * 1.005, cand1_f * 0.995))
ret = _randomized_roundoff_to_bfloat16(x, noise, cand1, cand2)
return ret * tf.to_bfloat16(x_sign)
def _weights_for_nonzero_refs(source_waveforms, consider_as_zero=None):
"""Return shape (batch, source) weights for signals that are nonzero.
Args:
source_waveforms: A tensor (batch, source, samples), dtype=tf.float32.
consider_as_zero: An optional tensor (batch, source), dtype=tf.bool which
indicates some entries as being zero even if they are not exactly zero.
This can be used to indicate some source types (e.g. noise) as being
zero regardless of their norm.
Returns:
consider_nonzero: A tensor (batch, source), dtype=tf.bool of sources
that will be considered as non-zero based on their norm being greater than
1e-8 or they are not in consider_as_zero array if given.
"""
source_norms = tf.sqrt(tf.reduce_mean(tf.square(source_waveforms),
axis=-1))
consider_nonzero = tf.greater(source_norms, 1e-8)
if consider_as_zero is not None:
consider_nonzero = tf.logical_and(consider_nonzero,
tf.logical_not(consider_as_zero))
return consider_nonzero
