def test_raises_when_positive(self):
with self.test_session():
rachel = tf.constant([0, 2], name="rachel")
with tf.control_dependencies([tf.assert_non_positive(rachel)]):
out = tf.identity(rachel)
with self.assertRaisesOpError("rachel"):
out.eval()
def bounds_unlabeled(lower: float,
upper: float,
tensor: tf.Tensor,
name: Optional[str] = None) -> tf.Tensor:
"""Checks the tensor elements fall in the given bounds.
Args:
lower: The lower bound.
upper: The upper bound.
tensor: The input tensor.
name: Optional op name.
Returns:
The input tensor.
"""
with tf.name_scope(name, 'check_bounds', [tensor]) as scope:
if FLAGS.tensorcheck_enable_checks:
lower_bound_op = tf.assert_non_negative(
tensor - lower, name='lower_bound')
upper_bound_op = tf.assert_non_positive(
tensor - upper, name='upper_bound')
with tf.control_dependencies([lower_bound_op, upper_bound_op]):
tensor = tf.identity(tensor, name=scope)
return tensor
def test_raises_when_positive(self):
with self.test_session():
rachel = tf.constant([0, 2], name="rachel")
with tf.control_dependencies([tf.assert_non_positive(rachel)]):
out = tf.identity(rachel)
with self.assertRaisesOpError("rachel"):
out.eval()
def rois_in_tiles_relative(tiles,
rois,
tile_size,
max_per_tile,
assert_on_overflow=True):
rois, overflow = remove_non_intersecting_rois(
tiles, rois, max_per_tile) # [n_tiles, max_per_tile, 4]
if assert_on_overflow:
with tf.control_dependencies([
tf.assert_non_positive(
overflow,
message=
"ROI per tile overflow. Set MAX_TARGET_ROIS_PER_TILE to a larger value."
)
]):
rois = tf.identity(rois)
is_roi_empty = find_empty_rois(rois)
is_roi_empty = tf.stack(
[is_roi_empty, is_roi_empty, is_roi_empty, is_roi_empty], axis=-1)
tiles = tf.expand_dims(tiles, axis=1) # force broadcasting on correct axis
tile_x1, tile_y1, tile_x2, tile_y2 = tf.unstack(
tiles, axis=2) # shape [n_tiles, 1]
roi_x1, roi_y1, roi_x2, roi_y2 = tf.unstack(
rois, axis=2) # shape [n_tiles, max_per_tile]
roi_x1 = (
roi_x1 - tile_x1
) / tile_size # shapes [n_tiles, max_per_tile] x [n_tiles] broadcast
roi_x2 = (roi_x2 - tile_x1) / tile_size
roi_y1 = (roi_y1 - tile_y1) / tile_size
roi_y2 = (roi_y2 - tile_y1) / tile_size
rois = tf.stack([roi_x1, roi_y1, roi_x2, roi_y2],
axis=-1) # shape [n_tiles, max_per_tile, 4]
# replace empty ROIs by (0,0,0,0) for clarity
return tf.where(is_roi_empty, tf.zeros_like(rois), rois)
def _assert_valid_sample(self, x):
if not self.validate_args:
return x
return control_flow_ops.with_dependencies([
tf.assert_non_positive(x),
distribution_util.assert_close(tf.zeros([], dtype=self.dtype),
tf.reduce_logsumexp(x, axis=[-1])),
], x)
def _assert_valid_sample(self, x):
if not self.validate_args:
return x
return control_flow_ops.with_dependencies([
tf.assert_non_positive(x),
tf.assert_near(
tf.zeros([], dtype=self.dtype), tf.reduce_logsumexp(x, axis=[-1])),
], x)
def _test_assertions(inf_tensors, gen_tensors, eval_tensors):
"""Returns in-graph assertions for testing."""
observed, latents, divs, log_probs, elbo = inf_tensors
generated, sampled_latents = gen_tensors
eval_log_probs, = eval_tensors
# For RNN, we return None from infer_latents as an optimization.
if latents is None:
latents = sampled_latents
def _same_batch_and_sequence_size_asserts(t1, name1, t2, name2):
return [
tf.assert_equal(util.batch_size_from_nested_tensors(t1),
util.batch_size_from_nested_tensors(t2),
message="Batch: " + name1 + " vs " + name2),
tf.assert_equal(util.sequence_size_from_nested_tensors(t1),
util.sequence_size_from_nested_tensors(t2),
message="Steps: " + name1 + " vs " + name2),
]
def _same_shapes(nested1, nested2):
return snt.nest.flatten(
snt.nest.map(
lambda t1, t2: tf.assert_equal(tf.shape(t1),
tf.shape(t2),
message="Shapes: " + t1.name +
" vs " + t2.name), nested1,
nested2))
def _all_same_batch_and_sequence_sizes(nested):
batch_size = util.batch_size_from_nested_tensors(nested)
sequence_size = util.sequence_size_from_nested_tensors(nested)
return [
tf.assert_equal(tf.shape(tensor)[0],
batch_size,
message="Batch: " + tensor.name)
for tensor in snt.nest.flatten(nested)
] + [
tf.assert_equal(tf.shape(tensor)[1],
sequence_size,
message="Steps: " + tensor.name)
for tensor in snt.nest.flatten(nested)
]
assertions = [
tf.assert_non_negative(divs),
tf.assert_non_positive(log_probs),
] + _same_shapes(
(log_probs, log_probs, observed, latents),
(divs, eval_log_probs, generated,
sampled_latents)) + _all_same_batch_and_sequence_sizes(
(observed, latents, divs)) + _all_same_batch_and_sequence_sizes(
(generated, sampled_latents))
vars_ = tf.trainable_variables()
grads = tf.gradients(-elbo, vars_)
for (var, grad) in zip(vars_, grads):
assertions.append(tf.check_numerics(grad, "Gradient for " + var.name))
return assertions
def test_empty_tensor_doesnt_raise(self):
# A tensor is non-positive when it satisfies:
# For every element x_i in x, x_i <= 0
# and an empty tensor has no elements, so this is trivially satisfied.
# This is standard set theory.
with self.test_session():
empty = tf.constant([], name="empty")
with tf.control_dependencies([tf.assert_non_positive(empty)]):
out = tf.identity(empty)
out.eval()
def test_empty_tensor_doesnt_raise(self):
# A tensor is non-positive when it satisfies:
# For every element x_i in x, x_i <= 0
# and an empty tensor has no elements, so this is trivially satisfied.
# This is standard set theory.
with self.test_session():
empty = tf.constant([], name="empty")
with tf.control_dependencies([tf.assert_non_positive(empty)]):
out = tf.identity(empty)
out.eval()
def binomial_logprob(x, rho, N=255):
"""
:param x: discrete input in range(0, N), a `Tensor` with shape == (batch, K)
:param rho: mean parameter between 0 and 1, a `Tensor` with shape == (K)
:param N: number of categories, integer
:return: a `Tensor` with shape == (batch)
"""
# copied from https://github.com/tensorflow/tensorflow/blob/r1.8/tensorflow/contrib/distributions/python/ops/binomial.py
rho = rho * (1. - 2 * noise) + noise
unnormalized_activation = x * tf.log(noise + rho) + (N - x) * tf.log(
noise + 1 - rho) # shape == (batch, K)
log_normalization = tf.lgamma(1. + N -
x) + tf.lgamma(1. + x) - tf.lgamma(1. + N)
out = unnormalized_activation - log_normalization
# out = tf.Print(out, [tf.reduce_max(out)])
with tf.control_dependencies([tf.assert_non_positive(out)]):
return tf.check_numerics(out, "binomial_logprob")
def bernoulli_logprob(x, rho):
"""
:param x: binary input, A `Tensor` with shape == (batch, K)
:param rho: mean parameter between 0 and 1, A `Tensor` with shape == (K)
:return: a `Tensor` with shape == (batch)
:raises:
"""
activation = x * tf.log(noise + rho) + (1. - x) * tf.log(
noise + 1. - rho) # shape == (batch, K)
print_op = tf.print("logproib",
tf.count_nonzero(tf.greater(activation, 0.)))
with tf.control_dependencies([
tf.assert_non_positive(activation, message="logprob error"),
tf.check_numerics(activation, "logprob error"), print_op
]):
return activation
def __call__(self, x):
if not self.built:
self.build(x)
with tf.variable_scope("activation"):
x_expand = tf.expand_dims(x,
axis=0) # shape == (1, batch, n_input)
x_tiled = 255 * tf.tile(x_expand, multiples=(
self.k_samples, 1, 1)) # shape == (k_samples, batch, n_input)
# p(x|z)
lpxgivenz = tf.reduce_sum(binomial_logprob(x_tiled,
self.x_reconstr_means,
255),
axis=2) # shape == (k_samples, batch)
with tf.control_dependencies([tf.assert_non_positive(lpxgivenz)]):
# Monte carlo importance weighted integration
lpx = tf.reduce_logsumexp(lpxgivenz, axis=0) - np.log(
self.k_samples) # shape == (batch)
return lpx
def rois_in_tiles_relative_and_pad(tiles,
rois,
max_per_tile,
assert_on_overflow=True):
rois, overflow = remove_non_intersecting_rois_and_pad(
tiles, rois, max_per_tile) # [n_tiles, max_per_tile, 4]
rois = make_rois_relative_to_tiles(tiles, rois)
# replace empty ROIs by (0,0,0,0) for clarity
is_roi_empty = find_empty_rois(rois)
rois = zero_where(rois, is_roi_empty)
# Log error if padding overflow
if assert_on_overflow:
with tf.control_dependencies([
tf.assert_non_positive(
overflow,
message=
"ROI per tile overflow. Set MAX_TARGET_ROIS_PER_TILE to a larger value."
)
]):
rois = tf.identity(rois)
return rois
def rois_in_tiles_relative(tiles,
rois,
tile_size,
max_per_tile,
assert_on_overflow=True):
rois, overflow = assign_rois_to_intersecting_tiles(
tiles, rois, max_per_tile) # [n_tiles, n_rois, 4]
if assert_on_overflow:
with tf.control_dependencies([
tf.assert_non_positive(
overflow,
message=
"ROI per tile overflow. Set MAX_TARGET_ROIS_PER_TILE to a larger value."
)
]):
rois = tf.identity(rois)
is_roi_empty = find_empty_rois(rois)
is_roi_empty = tf.stack(
[is_roi_empty, is_roi_empty, is_roi_empty, is_roi_empty], axis=-1)
tiles = tf.expand_dims(tiles, axis=1) # force broadcasting on correct axis
tile_x1, tile_y1, tile_x2, tile_y2 = tf.unstack(
tiles, axis=2) # shape [n_tiles, 1]
roi_x1, roi_y1, roi_x2, roi_y2 = tf.unstack(
rois, axis=2) # shape [n_tiles, n_rois]
roi_x1 = (roi_x1 - tile_x1
) / tile_size # shapes [n_tiles, n_rois] x [n_tiles] broadcast
roi_x2 = (roi_x2 - tile_x1) / tile_size
roi_y1 = (roi_y1 - tile_y1) / tile_size
roi_y2 = (roi_y2 - tile_y1) / tile_size
rois = tf.stack([roi_x1, roi_y1, roi_x2, roi_y2],
axis=-1) # shape [n_tiles, n_rois, 4]
# replace empty ROIs by (0,0,0,0) for clarity
rois = tf.where(is_roi_empty, tf.zeros_like(rois), rois)
# since this function is used in Datasets, always pad the number of ROIs to max_per_tile so that ROIs can be batched
rois = tf.pad(rois, [[0, 0], [0, max_per_tile - tf.shape(rois)[1]], [0, 0]
]) # shape [n_tiles, max_per_tile, 4]
return rois
def test_doesnt_raise_when_zero_and_negative(self):
with self.test_session():
tom = tf.constant([0, -2], name="tom")
with tf.control_dependencies([tf.assert_non_positive(tom)]):
out = tf.identity(tom)
out.eval()
def test_doesnt_raise_when_zero_and_negative(self):
with self.test_session():
tom = tf.constant([0, -2], name="tom")
with tf.control_dependencies([tf.assert_non_positive(tom)]):
out = tf.identity(tom)
out.eval()