def test_prepend_dims(self):
with pytest.raises(ValueError, match='`ndims` must be >= 0: got -1'):
_ = prepend_dims(tf.constant(0.), ndims=-1)
x = tf.zeros([2, 3])
self.assertIs(prepend_dims(x, ndims=0), x)
with self.test_session() as sess:
# test static shape
x = np.random.normal(size=[2, 3])
y = prepend_dims(x, ndims=1)
self.assertEqual(get_static_shape(y), (1, 2, 3))
np.testing.assert_allclose(sess.run(y), x.reshape([1, 2, 3]))
# test partially dynamic shape
t = tf.placeholder(shape=[2, None], dtype=tf.float64)
y = prepend_dims(t, ndims=2)
self.assertEqual(get_static_shape(y), (1, 1, 2, None))
np.testing.assert_allclose(sess.run(y, feed_dict={t: x}),
x.reshape([1, 1, 2, 3]))
# test fully dynamic shape
t = tf.placeholder(shape=None, dtype=tf.float64)
y = prepend_dims(t, ndims=3)
self.assertEqual(get_static_shape(y), None)
np.testing.assert_allclose(sess.run(y, feed_dict={t: x}),
x.reshape([1, 1, 1, 2, 3]))
def run_check(x, k, dynamic_shape):
if dynamic_shape:
t = tf.placeholder(tf.int32, [None] * len(x.shape))
run = lambda sess, *args: sess.run(*args, feed_dict={t: x})
else:
t = tf.constant(x, dtype=tf.int32)
run = lambda sess, *args: sess.run(*args)
if len(x.shape) == k:
self.assertEqual(flatten_to_ndims(t, k), (t, None, None))
self.assertEqual(unflatten_from_ndims(t, None, None), t)
else:
if k == 1:
front_shape = tuple(x.shape)
static_front_shape = get_static_shape(t)
xx = x.reshape([-1])
else:
front_shape = tuple(x.shape)[:-(k - 1)]
static_front_shape = get_static_shape(t)[:-(k - 1)]
xx = x.reshape([-1] + list(x.shape)[-(k - 1):])
with self.test_session() as sess:
tt, s1, s2 = flatten_to_ndims(t, k)
self.assertEqual(s1, static_front_shape)
if not dynamic_shape:
self.assertEqual(s2, front_shape)
else:
self.assertEqual(tuple(run(sess, s2)), front_shape)
np.testing.assert_equal(run(sess, tt), xx)
np.testing.assert_equal(
run(sess, unflatten_from_ndims(tt, s1, s2)), x)
def _unsplit(self, x1, x2):
n1 = self._n_features // 2
n2 = self._n_features - n1
if self._secondary:
x1, x2 = x2, x1
assert (get_static_shape(x1)[self.axis] == n1)
assert (get_static_shape(x2)[self.axis] == n2)
return tf.concat([x1, x2], axis=self.axis)
def _check_scale_or_shift_shape(self, name, tensor, x2):
assert_op = assert_shape_equal(
tensor,
x2,
message='`{}.shape` expected to be {}, but got {}'.format(
name, get_static_shape(x2), get_static_shape(tensor)))
with assert_deps([assert_op]) as asserted:
if asserted: # pragma: no cover
tensor = tf.identity(tensor)
return tensor
def validate_conv2d_input(input, channels_last, arg_name='input'):
"""
Validate the input for 2-d convolution.
Args:
input: The input tensor, must be at least 4-d.
channels_last (bool): Whether or not the last dimension is the
channels dimension? (i.e., `data_format` is "NHWC")
arg_name (str): Name of the input argument.
Returns:
(tf.Tensor, int, str): The validated input tensor, the number of input
channels, and the data format.
"""
if channels_last:
input_spec = InputSpec(shape=('...', '?', '?', '?', '*'))
channel_axis = -1
data_format = 'NHWC'
else:
input_spec = InputSpec(shape=('...', '?', '*', '?', '?'))
channel_axis = -3
data_format = 'NCHW'
input = input_spec.validate(arg_name, input)
input_shape = get_static_shape(input)
in_channels = input_shape[channel_axis]
return input, in_channels, data_format
def prepend_dims(x, ndims=1, name=None):
"""
Prepend `[1] * ndims` to the beginning of the shape of `x`.
Args:
x: The tensor `x`.
ndims: Number of `1` to prepend.
Returns:
tf.Tensor: The tensor with prepended dimensions.
"""
ndims = int(ndims)
if ndims < 0:
raise ValueError('`ndims` must be >= 0: got {}'.format(ndims))
x = tf.convert_to_tensor(x)
if ndims == 0:
return x
with tf.name_scope(name, default_name='prepend_dims', values=[x]):
static_shape = get_static_shape(x)
if static_shape is not None:
static_shape = tf.TensorShape([1] * ndims + list(static_shape))
dynamic_shape = concat_shapes([[1] * ndims, get_shape(x)])
y = tf.reshape(x, dynamic_shape)
if static_shape is not None:
y.set_shape(static_shape)
return y
def _build(self, input=None):
dtype = input.dtype.base_dtype
n_units = get_static_shape(input)[self.axis]
w = model_variable('w',
shape=[1, n_units],
dtype=dtype,
initializer=self._w_initializer,
regularizer=self._w_regularizer,
trainable=self._trainable)
b = model_variable('b',
shape=[1],
dtype=dtype,
initializer=self._b_initializer,
regularizer=self._b_regularizer,
trainable=self._trainable)
u = model_variable('u',
shape=[1, n_units],
dtype=dtype,
initializer=self._u_initializer,
regularizer=self._u_regularizer,
trainable=self._trainable)
wu = tf.matmul(w, u, transpose_b=True) # wu.shape == [1]
u_hat = u + (-1 + tf.nn.softplus(wu) - wu) * \
w / tf.reduce_sum(tf.square(w)) # shape == [1, n_units]
self._w, self._b, self._u, self._u_hat = w, b, u, u_hat
def check(x, shape, x_ph=None, shape_ph=None, static_shape=None):
# compute the expected answer
try:
y = x * np.ones(tuple(shape), dtype=x.dtype)
if y.shape != shape:
raise ValueError()
except ValueError:
y = None
# call the function and get output
feed_dict = {}
if x_ph is not None:
feed_dict[x_ph] = x
x = x_ph
if shape_ph is not None:
feed_dict[shape_ph] = np.asarray(shape)
shape = shape_ph
if y is None:
with pytest.raises(Exception,
match='`x` cannot be broadcasted '
'to match `shape`'):
t = broadcast_to_shape_strict(x, shape)
_ = sess.run(t, feed_dict=feed_dict)
else:
t = broadcast_to_shape_strict(x, shape)
if static_shape is not None:
self.assertTupleEqual(get_static_shape(t), static_shape)
out = sess.run(t, feed_dict=feed_dict)
self.assertTupleEqual(out.shape, y.shape)
np.testing.assert_equal(out, y)
def check(x,
ndims,
shape,
expected_shape,
static_shape=None,
x_ph=None,
shape_ph=None):
# compute the answer
assert (len(x.shape) >= ndims)
if ndims > 0:
y = np.reshape(x, x.shape[:-ndims] + tuple(shape))
else:
y = np.reshape(x, x.shape + tuple(shape))
self.assertEqual(y.shape, expected_shape)
# validate the output
feed_dict = {}
if x_ph is not None:
feed_dict[x_ph] = x
x = x_ph
if shape_ph is not None:
feed_dict[shape_ph] = shape
shape = shape_ph
y_tensor = reshape_tail(x, ndims, shape)
if static_shape is not None:
self.assertTupleEqual(get_static_shape(y_tensor), static_shape)
y_out = sess.run(y_tensor, feed_dict=feed_dict)
self.assertTupleEqual(y_out.shape, y.shape)
np.testing.assert_equal(y_out, y)
def _build(self, input=None):
n_features = get_static_shape(input)[self.axis]
if n_features < 2:
raise ValueError('The feature axis of `input` must be at least 2: '
'got {}, input {}, axis {}.'.format(
n_features, input, self.axis))
self._n_features = n_features
def test_sample(self):
tf.set_random_seed(123456)
mean = tf.constant([0., 1., 2.], dtype=tf.float64)
normal = Normal(mean=mean, std=tf.constant(1., dtype=tf.float64))
flow = QuadraticFlow(2., 5.)
distrib = FlowDistribution(normal, flow)
# test ordinary sample, is_reparameterized = None
y = distrib.sample(n_samples=5)
self.assertTrue(y.is_reparameterized)
grad = tf.gradients(y * 1., mean)[0]
self.assertIsNotNone(grad)
self.assertEqual(get_static_shape(y), (5, 3))
self.assertIsNotNone(y._self_log_prob)
x, log_det = flow.inverse_transform(y)
log_py = normal.log_prob(x) + log_det
with self.test_session() as sess:
np.testing.assert_allclose(*sess.run([log_py, y.log_prob()]),
rtol=1e-5)
# test stop gradient sample, is_reparameterized = False
y = distrib.sample(n_samples=5, is_reparameterized=False)
self.assertFalse(y.is_reparameterized)
grad = tf.gradients(y * 1., mean)[0]
self.assertIsNone(grad)
def _build(self, input=None):
# check the input.
input = tf.convert_to_tensor(input)
dtype = input.dtype.base_dtype
shape = get_static_shape(input)
# These facts should have been checked in `BaseFlow.build`.
assert (shape is not None)
assert (len(shape) >= self.value_ndims)
# compute var spec and input spec
min_axis = min(self.axis)
shape_spec = [None] * len(shape)
for a in self.axis:
shape_spec[a] = shape[a]
shape_spec = shape_spec[min_axis:]
assert (not not shape_spec)
assert (self.value_ndims >= len(shape_spec))
self._y_input_spec = self._x_input_spec = InputSpec(
shape=(('...', ) + ('?', ) * (self.value_ndims - len(shape_spec)) +
tuple(shape_spec)),
dtype=dtype)
# the shape of variables must only have necessary dimensions,
# such that we can switch freely between `channels_last = True`
# (in which case `input.shape = (..., *,)`, and `channels_last = False`
# (in which case `input.shape = (..., *, 1, 1)`.
self._var_shape = tuple(s for s in shape_spec if s is not None)
# and we still need to compute the aligned variable shape, such that
# we can immediately reshape the variables into this aligned shape,
# then compute `scale * input + bias`.
self._var_shape_aligned = tuple(s or 1 for s in shape_spec)
self._var_spec = ParamSpec(self._var_shape)
# validate the input
self._x_input_spec.validate('input', input)
# build the variables
self._bias = model_variable('bias',
dtype=dtype,
shape=self._var_shape,
regularizer=self._bias_regularizer,
constraint=self._bias_constraint,
trainable=self._trainable)
if self._scale_type == 'exp':
self._pre_scale = model_variable(
'log_scale',
dtype=dtype,
shape=self._var_shape,
regularizer=self._log_scale_regularizer,
constraint=self._log_scale_constraint,
trainable=self._trainable)
else:
self._pre_scale = model_variable(
'scale',
dtype=dtype,
shape=self._var_shape,
regularizer=self._scale_regularizer,
constraint=self._scale_constraint,
trainable=self._trainable)
def test_sample_value_and_group_ndims(self):
tf.set_random_seed(123456)
mean = tf.constant([0., 1., 2.], dtype=tf.float64)
normal = Normal(mean=mean, std=tf.constant(1., dtype=tf.float64))
with self.test_session() as sess:
# test value_ndims = 0, group_ndims = 1
flow = QuadraticFlow(2., 5.)
distrib = FlowDistribution(normal, flow)
self.assertEqual(distrib.value_ndims, 0)
y = distrib.sample(n_samples=5, group_ndims=1)
self.assertTupleEqual(get_static_shape(y), (5, 3))
x, log_det = flow.inverse_transform(y)
self.assertTupleEqual(get_static_shape(x), (5, 3))
self.assertTupleEqual(get_static_shape(log_det), (5, 3))
log_py = tf.reduce_sum(normal.log_prob(x) + log_det, axis=-1)
np.testing.assert_allclose(*sess.run([y.log_prob(), log_py]),
rtol=1e-5)
# test value_ndims = 1, group_ndims = 0
flow = QuadraticFlow(2., 5., value_ndims=1)
distrib = FlowDistribution(normal, flow)
self.assertEqual(distrib.value_ndims, 1)
y = distrib.sample(n_samples=5, group_ndims=0)
self.assertTupleEqual(get_static_shape(y), (5, 3))
x, log_det = flow.inverse_transform(y)
self.assertTupleEqual(get_static_shape(x), (5, 3))
self.assertTupleEqual(get_static_shape(log_det), (5,))
log_py = log_det + tf.reduce_sum(normal.log_prob(x), axis=-1)
np.testing.assert_allclose(*sess.run([y.log_prob(), log_py]),
rtol=1e-5)
# test value_ndims = 1, group_ndims = 1
flow = QuadraticFlow(2., 5., value_ndims=1)
distrib = FlowDistribution(normal, flow)
self.assertEqual(distrib.value_ndims, 1)
y = distrib.sample(n_samples=5, group_ndims=1)
self.assertTupleEqual(get_static_shape(y), (5, 3))
x, log_det = flow.inverse_transform(y)
self.assertTupleEqual(get_static_shape(x), (5, 3))
self.assertTupleEqual(get_static_shape(log_det), (5,))
log_py = tf.reduce_sum(
log_det + tf.reduce_sum(normal.log_prob(x), axis=-1))
np.testing.assert_allclose(*sess.run([y.log_prob(), log_py]),
rtol=1e-5)
def _build(self, input=None):
shape = get_static_shape(input)
dtype = input.dtype.base_dtype
assert (shape is not None and len(shape) >= self.x_value_ndims)
# re-build the x input spec
x_shape_spec = []
if self.x_value_ndims > 0:
x_shape_spec = list(shape)[-self.x_value_ndims:]
if self.require_batch_dims:
x_shape_spec = ['?'] + x_shape_spec
x_shape_spec = ['...'] + x_shape_spec
self._x_input_spec = InputSpec(shape=x_shape_spec, dtype=dtype)
# infer the dynamic value shape of x, and store it for inverse transform
x_value_shape = []
if self.x_value_ndims > 0:
x_value_shape = list(shape)[-self.x_value_ndims:]
neg_one_count = 0
for i, s in enumerate(x_value_shape):
if s is None:
if neg_one_count > 0:
x_value_shape = get_shape(input)
if self.x_value_ndims > 0:
x_value_shape = x_value_shape[-self.x_value_ndims:]
break
else:
x_value_shape[i] = -1
neg_one_count += 1
self._x_value_shape = x_value_shape
# now infer the y value shape according to new info obtained from x
y_value_shape = list(self._y_value_shape)
if isinstance(x_value_shape, list) and -1 not in x_value_shape:
x_value_size = int(np.prod(x_value_shape))
y_value_size = int(np.prod([s for s in y_value_shape if s != -1]))
if (-1 in y_value_shape and x_value_size % y_value_size != 0) or \
(-1 not in y_value_shape and x_value_size != y_value_size):
raise ValueError(
'Cannot reshape the tail dimensions of `x` into `y`: '
'x value shape {!r}, y value shape {!r}.'.format(
x_value_shape, y_value_shape))
if -1 in y_value_shape:
y_value_shape[y_value_shape.index(-1)] = \
x_value_size // y_value_size
assert (-1 not in y_value_shape)
self._y_value_shape = tuple(y_value_shape)
# re-build the y input spec
y_shape_spec = list(y_value_shape)
if self.require_batch_dims:
y_shape_spec = ['?'] + y_shape_spec
y_shape_spec = ['...'] + y_shape_spec
self._y_input_spec = InputSpec(shape=y_shape_spec, dtype=dtype)
def broadcast_to_shape_strict(x, shape, name=None):
"""
Broadcast `x` to match `shape`.
This method requires `rank(x)` to be less than or equal to `len(shape)`.
You may use :func:`broadcast_to_shape` instead, to allow the cases where
``rank(x) > len(shape)``.
Args:
x: A tensor.
shape (tuple[int] or tf.Tensor): Broadcast `x` to match this shape.
Returns:
tf.Tensor: The broadcasted tensor.
"""
# check the parameters
x = tf.convert_to_tensor(x)
x_shape = get_static_shape(x)
ns_values = [x]
if is_tensor_object(shape):
shape = tf.convert_to_tensor(shape)
ns_values.append(shape)
else:
shape = tuple(int(s) for s in shape)
with tf.name_scope(name=name or 'broadcast_to_shape', values=ns_values):
cannot_broadcast_msg = (
'`x` cannot be broadcasted to match `shape`: x {!r} vs shape {!r}'.
format(x, shape))
# assert ``rank(x) <= len(shape)``
if isinstance(shape, tuple) and x_shape is not None:
if len(x_shape) > len(shape):
raise ValueError(cannot_broadcast_msg)
elif isinstance(shape, tuple):
with assert_deps([
tf.assert_less_equal(tf.rank(x),
len(shape),
message=cannot_broadcast_msg)
]) as asserted:
if asserted: # pragma: no cover
x = tf.identity(x)
else:
with assert_deps(
[assert_rank(shape, 1,
message=cannot_broadcast_msg)]) as asserted:
if asserted: # pragma: no cover
shape = tf.identity(shape)
with assert_deps([
tf.assert_less_equal(tf.rank(x),
tf.size(shape),
message=cannot_broadcast_msg)
]) as asserted:
if asserted: # pragma: no cover
x = tf.identity(x)
# do broadcast
return broadcast_to_shape(x, shape)
def _transform_or_inverse_transform(self, x, compute_y, compute_log_det,
permutation):
assert (0 > self.axis >= -self.value_ndims >= -len(get_static_shape(x)))
assert (get_static_shape(x)[self.axis] == self._n_features)
# compute y
y = None
if compute_y:
y = tf.gather(x, permutation, axis=self.axis)
# compute log_det
log_det = None
if compute_log_det:
log_det = ZeroLogDet(get_shape(x)[:-self.value_ndims],
x.dtype.base_dtype)
return y, log_det
def _build_input_spec(self, input):
super(FeatureMappingFlow, self)._build_input_spec(input)
dtype = input.dtype.base_dtype
shape = get_static_shape(input)
# These facts should have been checked in `BaseFlow.build`.
assert (shape is not None)
assert (len(shape) >= self.value_ndims)
# validate the feature axis, ensure it is covered by `value_ndims`.
axis = self._axis
axis_is_int = is_integer(axis)
if axis_is_int:
axis = [axis]
else:
axis = list(axis)
for i, a in enumerate(axis):
if a < 0:
a += len(shape)
if a < 0 or a < len(shape) - self.value_ndims:
raise ValueError('`axis` out of range, or not covered by '
'`value_ndims`: axis {}, value_ndims {}, '
'input {}'.format(self._axis,
self.value_ndims, input))
if shape[a] is None:
raise ValueError('The feature axis of `input` is not '
'deterministic: input {}, axis {}'.format(
input, self._axis))
# Store the negative axis, such that when new inputs can have more
# dimensions than this `input`, the axis can still be correctly
# resolved.
axis[i] = a - len(shape)
if axis_is_int:
assert (len(axis) == 1)
self._axis = axis[0]
else:
axis_len = len(axis)
axis = tuple(sorted(set(axis)))
if len(axis) != axis_len:
raise ValueError(
'Duplicated elements after resolving negative '
'`axis` with respect to the `input`: '
'input {}, axis {}'.format(input, self._axis))
self._axis = tuple(axis)
# re-build the input spec
batch_ndims = int(self.require_batch_dims)
shape_spec = ['...'] + ['?'] * (self.value_ndims + batch_ndims)
for a in axis:
shape_spec[a] = shape[a]
self._y_input_spec = self._x_input_spec = InputSpec(shape=shape_spec,
dtype=dtype)
self._x_input_spec.validate('input', input)
def _build(self, input=None):
n_features = self._n_features = get_static_shape(input)[self.axis]
permutation = np.arange(n_features, dtype=np.int32)
self._random_state.shuffle(permutation)
self._permutation = model_variable(
'permutation', dtype=tf.int32, initializer=permutation,
trainable=False
)
self._inv_permutation = tf.invert_permutation(self._permutation)
def _split(self, x):
n_features = get_static_shape(x)[self.axis]
assert (self._n_features == n_features)
n1 = n_features // 2
n2 = n_features - n1
x1, x2 = tf.split(x, [n1, n2], self.axis)
if self._secondary:
return x2, x1, n1
else:
return x1, x2, n2
def _build(self, input=None):
dtype = input.dtype.base_dtype
n_features = get_static_shape(input)[self.axis]
self._kernel_matrix = InvertibleMatrix(size=n_features,
strict=self._strict_invertible,
dtype=dtype,
trainable=self._trainable,
random_state=self._random_state,
scope='kernel')
def assert_rank(x, ndims, message=None, name=None):
"""
Assert the rank of `x` is `ndims`.
Args:
x: A tensor.
ndims (int or tf.Tensor): An integer, or a 0-d integer tensor.
message: Message to display when assertion failed.
Returns:
tf.Operation or None: The TensorFlow assertion operation,
or None if can be statically asserted.
"""
if not is_tensor_object(ndims) and get_static_shape(x) is not None:
ndims = int(ndims)
x_ndims = len(get_static_shape(x))
if x_ndims != ndims:
raise _make_assertion_error('rank(x) == ndims',
'{!r} != {!r}'.format(x_ndims,
ndims), message)
else:
return tf.assert_rank(x, ndims, message=message, name=name)
def check(input_size, kernel_size, strides, padding):
output_size = get_deconv_output_length(input_size, kernel_size,
strides, padding)
self.assertGreater(output_size, 0)
# assert input <- output
x = tf.nn.conv2d(np.zeros([1, output_size, output_size, 1],
dtype=np.float32),
filter=np.zeros([kernel_size, kernel_size, 1, 1]),
strides=[1, strides, strides, 1],
padding=padding.upper(),
data_format='NHWC')
h, w = get_static_shape(x)[1:3]
self.assertEqual(input_size, h)
def flatten_to_ndims(x, ndims, name=None):
"""
Flatten the front dimensions of `x`, such that the resulting tensor
will have at most `ndims` dimensions.
Args:
x (Tensor): The tensor to be flatten.
ndims (int): The maximum number of dimensions for the resulting tensor.
Returns:
(tf.Tensor, tuple[int or None], tuple[int] or tf.Tensor) or (tf.Tensor, None, None):
(The flatten tensor, the static front shape, and the front shape),
or (the original tensor, None, None)
"""
x = tf.convert_to_tensor(x)
if ndims < 1:
raise ValueError('`k` must be greater or equal to 1.')
if not x.get_shape():
raise ValueError('`x` is required to have known number of '
'dimensions.')
shape = get_static_shape(x)
if len(shape) < ndims:
raise ValueError('`k` is {}, but `x` only has rank {}.'.format(
ndims, len(shape)))
if len(shape) == ndims:
return x, None, None
with tf.name_scope(name, default_name='flatten', values=[x]):
if ndims == 1:
static_shape = shape
if None in shape:
shape = tf.shape(x)
return tf.reshape(x, [-1]), static_shape, shape
else:
front_shape, back_shape = shape[:-(ndims - 1)], shape[-(ndims -
1):]
static_front_shape = front_shape
static_back_shape = back_shape
if None in front_shape or None in back_shape:
dynamic_shape = tf.shape(x)
if None in front_shape:
front_shape = dynamic_shape[:-(ndims - 1)]
if None in back_shape:
back_shape = dynamic_shape[-(ndims - 1):]
if isinstance(back_shape, tuple):
x = tf.reshape(x, [-1] + list(back_shape))
else:
x = tf.reshape(x, tf.concat([[-1], back_shape], axis=0))
x.set_shape(tf.TensorShape([None] + list(static_back_shape)))
return x, static_front_shape, front_shape
def _build(self, input=None):
shape = get_static_shape(input)
dtype = input.dtype.base_dtype
# resolve the split axis
split_axis = self._split_axis
if split_axis < 0:
split_axis += len(shape)
if split_axis < 0 or split_axis < len(shape) - self.x_value_ndims:
raise ValueError(
'`split_axis` out of range, or not covered by `x_value_ndims`: '
'split_axis {}, x_value_ndims {}, input {}'.format(
self._split_axis, self.x_value_ndims, input))
split_axis -= len(shape)
err_msg = (
'The split axis of `input` must be at least 2: input {}, axis {}.'.
format(input, split_axis))
if shape[split_axis] is not None:
x_n_features = shape[split_axis]
if x_n_features < 2:
raise ValueError(err_msg)
x_n_left = x_n_features // 2
x_n_right = x_n_features - x_n_left
else:
x_n_features = get_shape(input)[split_axis]
x_n_left = x_n_features // 2
x_n_right = x_n_features - x_n_left
with assert_deps(
[tf.assert_greater_equal(x_n_features, 2,
message=err_msg)]) as asserted:
if asserted: # pragma: no cover
x_n_left = tf.identity(x_n_left)
x_n_right = tf.identity(x_n_right)
x_n_features = None
self._split_axis = split_axis
self._x_n_left = x_n_left
self._x_n_right = x_n_right
# build the x spec
shape_spec = ['?'] * self.x_value_ndims
if x_n_features is not None:
shape_spec[self._split_axis] = x_n_features
assert (not self.require_batch_dims)
shape_spec = ['...'] + shape_spec
self._x_input_spec = InputSpec(shape=shape_spec, dtype=dtype)
def test_u_hat(self):
n_units = 5
tf.set_random_seed(1234)
flow = PlanarNormalizingFlow(name='planar_nf')
flow.apply(tf.random_normal(shape=[1, n_units]))
# ensure these parameters exist
w, b, u, u_hat = flow._w, flow._b, flow._u, flow._u_hat
for v in [w, u, b, u_hat]:
self.assertIn('planar_nf/', v.name)
# ensure these parameters have expected shapes
self.assertEqual(get_static_shape(w), (1, n_units))
self.assertEqual(get_static_shape(u), (1, n_units))
self.assertEqual(get_static_shape(b), (1, ))
self.assertEqual(get_static_shape(u_hat), (1, n_units))
with self.test_session() as sess:
ensure_variables_initialized()
w, b, u, u_hat = sess.run([w, b, u, u_hat])
m = lambda a: -1 + np.log(1 + np.exp(a))
wu = np.dot(w, u.T) # shape: [1]
np.testing.assert_allclose(u + w * (m(wu) - wu) / np.sum(w**2),
u_hat)
def test_log_prob_value_and_group_ndims(self):
tf.set_random_seed(123456)
mean = tf.constant([0., 1., 2.], dtype=tf.float64)
normal = Normal(mean=mean, std=tf.constant(1., dtype=tf.float64))
y = tf.random_normal(shape=[2, 5, 3], dtype=tf.float64)
with self.test_session() as sess:
# test value_ndims = 0, group_ndims = 1
flow = QuadraticFlow(2., 5.)
flow.build(tf.zeros([2, 5, 3], dtype=tf.float64))
distrib = FlowDistribution(normal, flow)
self.assertEqual(distrib.value_ndims, 0)
x, log_det = flow.inverse_transform(y)
self.assertTupleEqual(get_static_shape(x), (2, 5, 3))
self.assertTupleEqual(get_static_shape(log_det), (2, 5, 3))
log_py = tf.reduce_sum(normal.log_prob(x) + log_det, axis=-1)
np.testing.assert_allclose(
*sess.run([distrib.log_prob(y, group_ndims=1), log_py]),
rtol=1e-5
)
# test value_ndims = 1, group_ndims = 0
flow = QuadraticFlow(2., 5., value_ndims=1)
flow.build(tf.zeros([2, 5, 3], dtype=tf.float64))
distrib = FlowDistribution(normal, flow)
self.assertEqual(distrib.value_ndims, 1)
x, log_det = flow.inverse_transform(y)
self.assertTupleEqual(get_static_shape(x), (2, 5, 3))
self.assertTupleEqual(get_static_shape(log_det), (2, 5))
log_py = normal.log_prob(x, group_ndims=1) + log_det
np.testing.assert_allclose(
*sess.run([distrib.log_prob(y, group_ndims=0), log_py]),
rtol=1e-5
)
# test value_ndims = 1, group_ndims = 2
flow = QuadraticFlow(2., 5., value_ndims=1)
flow.build(tf.zeros([2, 5, 3], dtype=tf.float64))
distrib = FlowDistribution(normal, flow)
self.assertEqual(distrib.value_ndims, 1)
x, log_det = flow.inverse_transform(y)
self.assertTupleEqual(get_static_shape(x), (2, 5, 3))
self.assertTupleEqual(get_static_shape(log_det), (2, 5))
log_py = tf.reduce_sum(
log_det + tf.reduce_sum(normal.log_prob(x), axis=-1))
np.testing.assert_allclose(
*sess.run([distrib.log_prob(y, group_ndims=2), log_py]),
rtol=1e-5
)
def _transform(self, x, compute_y, compute_log_det):
assert (len(get_static_shape(x)) >= self.x_value_ndims)
# compute y
y = None
if compute_y:
y = reshape_tail(x, self.x_value_ndims, self._y_value_shape)
# compute log_det
log_det = None
if compute_log_det:
dst_shape = get_shape(x)
if self.x_value_ndims > 0:
dst_shape = dst_shape[:-self.x_value_ndims]
log_det = ZeroLogDet(dst_shape, dtype=x.dtype.base_dtype)
return y, log_det
def _inverse_transform(self, y, compute_x, compute_log_det):
assert (len(get_static_shape(y)) >= self.y_value_ndims)
# compute y
x = None
if compute_x:
x = reshape_tail(y, self.y_value_ndims, self._x_value_shape)
# compute log_det
log_det = None
if compute_log_det:
dst_shape = get_shape(y)
if self.y_value_ndims > 0:
dst_shape = dst_shape[:-self.y_value_ndims]
log_det = ZeroLogDet(dst_shape, dtype=y.dtype.base_dtype)
return x, log_det
def _transform(self, x, compute_y, compute_log_det):
# compute y
y = None
if compute_y:
n_features = get_static_shape(x)[self.axis]
y = dense(x,
n_features,
kernel=self._kernel_matrix.matrix,
use_bias=False)
# compute log_det
log_det = None
if compute_log_det:
log_det = apply_log_det_factor(self._kernel_matrix.log_det, x,
self.axis, self.value_ndims)
log_det = broadcast_log_det_against_input(
log_det, x, value_ndims=self.value_ndims)
return y, log_det
def classification_accuracy(y_pred, y_true, name=None):
"""
Compute the classification accuracy for `y_pred` and `y_true`.
Args:
y_pred: The predicted labels.
y_true: The ground truth labels. Its shape must match `y_pred`.
Returns:
tf.Tensor: The accuracy.
"""
y_pred = tf.convert_to_tensor(y_pred)
y_true = InputSpec(shape=get_static_shape(y_pred)). \
validate('y_true', y_true)
with tf.name_scope(name,
default_name='classification_accuracy',
values=[y_pred, y_true]):
return tf.reduce_mean(
tf.cast(tf.equal(y_pred, y_true), dtype=tf.float32))
