tfp.bijectors.AffineScalar

Class `AffineScalar`

Compute Y = g(X; shift, scale) = scale * X + shift.

Inherits From: Bijector

Examples:

# Y = X
b = AffineScalar()

# Y = X + shift
b = AffineScalar(shift=[1., 2, 3])

# Y = 2 * X + shift
b = AffineScalar(
  shift=[1., 2, 3],
  scale=2.)

`init`

View source

__init__(
    shift=None,
    scale=None,
    log_scale=None,
    validate_args=False,
    name='affine_scalar'
)

Instantiates the AffineScalar bijector.

This Bijector is initialized with shift Tensor and scale arguments, giving the forward operation:

Y = g(X) = scale * X + shift

Alternatively, you can specify log_scale instead of scale for slighly better numerics with tiny scales. Note that when using log_scale it is currently impossible to specify a negative scale.

If scale or log_scale are not specified, then the bijector has the semantics of scale = 1.. Similarly, if shift is not specified, then the bijector has the semantics of shift = 0..

Args:

shift: Floating-point Tensor. If this is set to None, no shift is applied.
scale: Floating-point Tensor. If this is set to None, no scale is applied. This should not be set if log_scale is set.
log_scale: Floating-point Tensor. Logarithm of the scale. If this is set to None, no scale is applied. This should not be set if scale is set.
validate_args: Python bool indicating whether arguments should be checked for correctness.
name: Python str name given to ops managed by this object.

Raises:

ValueError: If both scale and log_scale are specified.

Properties

`dtype`

dtype of Tensors transformable by this distribution.

`forward_min_event_ndims`

Returns the minimal number of dimensions bijector.forward operates on.

`graph_parents`

Returns this Bijector's graph_parents as a Python list.

`inverse_min_event_ndims`

Returns the minimal number of dimensions bijector.inverse operates on.

`is_constant_jacobian`

Returns true iff the Jacobian matrix is not a function of x.

Returns:

is_constant_jacobian: Python bool.

`log_scale`

The log_scale term in Y = exp(log_scale) * X + shift.

`name`

Returns the string name of this Bijector.

`name_scope`

Returns a tf.name_scope instance for this class.

`scale`

The scale term in Y = scale * X + shift.

`shift`

The shift term in Y = scale * X + shift.

`submodules`

Sequence of all sub-modules.

Submodules are modules which are properties of this module, or found as properties of modules which are properties of this module (and so on).

a = tf.Module()
b = tf.Module()
c = tf.Module()
a.b = b
b.c = c
assert list(a.submodules) == [b, c]
assert list(b.submodules) == [c]
assert list(c.submodules) == []

Returns:

A sequence of all submodules.

`trainable_variables`

Sequence of variables owned by this module and it's submodules.

Returns:

A sequence of variables for the current module (sorted by attribute name) followed by variables from all submodules recursively (breadth first).

`validate_args`

Returns True if Tensor arguments will be validated.

`variables`

Sequence of variables owned by this module and it's submodules.

Returns:

A sequence of variables for the current module (sorted by attribute name) followed by variables from all submodules recursively (breadth first).

Methods

`call`

View source

__call__(
    value,
    name=None,
    **kwargs
)

Applies or composes the Bijector, depending on input type.

This is a convenience function which applies the Bijector instance in three different ways, depending on the input:

If the input is a tfd.Distribution instance, return tfd.TransformedDistribution(distribution=input, bijector=self).
If the input is a tfb.Bijector instance, return tfb.Chain([self, input]).
Otherwise, return self.forward(input)

Args:

value: A tfd.Distribution, tfb.Bijector, or a Tensor.
name: Python str name given to ops created by this function.
**kwargs: Additional keyword arguments passed into the created tfd.TransformedDistribution, tfb.Bijector, or self.forward.

Returns:

composition: A tfd.TransformedDistribution if the input was a tfd.Distribution, a tfb.Chain if the input was a tfb.Bijector, or a Tensor computed by self.forward.

Examples

sigmoid = tfb.Reciprocal()(
    tfb.AffineScalar(shift=1.)(
      tfb.Exp()(
        tfb.AffineScalar(scale=-1.))))
# ==> `tfb.Chain([
#         tfb.Reciprocal(),
#         tfb.AffineScalar(shift=1.),
#         tfb.Exp(),
#         tfb.AffineScalar(scale=-1.),
#      ])`  # ie, `tfb.Sigmoid()`

log_normal = tfb.Exp()(tfd.Normal(0, 1))
# ==> `tfd.TransformedDistribution(tfd.Normal(0, 1), tfb.Exp())`

tfb.Exp()([-1., 0., 1.])
# ==> tf.exp([-1., 0., 1.])

`forward`

View source

forward(
    x,
    name='forward',
    **kwargs
)

Returns the forward Bijector evaluation, i.e., X = g(Y).

Args:

x: Tensor. The input to the 'forward' evaluation.
name: The name to give this op.
**kwargs: Named arguments forwarded to subclass implementation.

Returns:

Tensor.

Raises:

TypeError: if self.dtype is specified and x.dtype is not self.dtype.
NotImplementedError: if _forward is not implemented.

`forward_event_shape`

View source

forward_event_shape(input_shape)

Shape of a single sample from a single batch as a TensorShape.

Same meaning as forward_event_shape_tensor. May be only partially defined.

Args:

input_shape: TensorShape indicating event-portion shape passed into forward function.

Returns:

forward_event_shape_tensor: TensorShape indicating event-portion shape after applying forward. Possibly unknown.

`forward_event_shape_tensor`

View source

forward_event_shape_tensor(
    input_shape,
    name='forward_event_shape_tensor'
)

Shape of a single sample from a single batch as an int32 1D Tensor.

Args:

input_shape: Tensor, int32 vector indicating event-portion shape passed into forward function.
name: name to give to the op

Returns:

forward_event_shape_tensor: Tensor, int32 vector indicating event-portion shape after applying forward.

`forward_log_det_jacobian`

View source

forward_log_det_jacobian(
    x,
    event_ndims,
    name='forward_log_det_jacobian',
    **kwargs
)

Returns both the forward_log_det_jacobian.

Args:

x: Tensor. The input to the 'forward' Jacobian determinant evaluation.
event_ndims: Number of dimensions in the probabilistic events being transformed. Must be greater than or equal to self.forward_min_event_ndims. The result is summed over the final dimensions to produce a scalar Jacobian determinant for each event, i.e. it has shape rank(x) - event_ndims dimensions.
name: The name to give this op.
**kwargs: Named arguments forwarded to subclass implementation.

Returns:

Tensor, if this bijector is injective. If not injective this is not implemented.

Raises:

TypeError: if self.dtype is specified and y.dtype is not self.dtype.
NotImplementedError: if neither _forward_log_det_jacobian nor {_inverse, _inverse_log_det_jacobian} are implemented, or this is a non-injective bijector.

`inverse`

View source

inverse(
    y,
    name='inverse',
    **kwargs
)

Returns the inverse Bijector evaluation, i.e., X = g^{-1}(Y).

Args:

y: Tensor. The input to the 'inverse' evaluation.
name: The name to give this op.
**kwargs: Named arguments forwarded to subclass implementation.

Returns:

Tensor, if this bijector is injective. If not injective, returns the k-tuple containing the unique k points (x1, ..., xk) such that g(xi) = y.

Raises:

TypeError: if self.dtype is specified and y.dtype is not self.dtype.
NotImplementedError: if _inverse is not implemented.

`inverse_event_shape`

View source

inverse_event_shape(output_shape)

Shape of a single sample from a single batch as a TensorShape.

Same meaning as inverse_event_shape_tensor. May be only partially defined.

Args:

output_shape: TensorShape indicating event-portion shape passed into inverse function.

Returns:

inverse_event_shape_tensor: TensorShape indicating event-portion shape after applying inverse. Possibly unknown.

`inverse_event_shape_tensor`

View source

inverse_event_shape_tensor(
    output_shape,
    name='inverse_event_shape_tensor'
)

Shape of a single sample from a single batch as an int32 1D Tensor.

Args:

output_shape: Tensor, int32 vector indicating event-portion shape passed into inverse function.
name: name to give to the op

Returns:

inverse_event_shape_tensor: Tensor, int32 vector indicating event-portion shape after applying inverse.

`inverse_log_det_jacobian`

View source

inverse_log_det_jacobian(
    y,
    event_ndims,
    name='inverse_log_det_jacobian',
    **kwargs
)

Returns the (log o det o Jacobian o inverse)(y).

Mathematically, returns: log(det(dX/dY))(Y). (Recall that: X=g^{-1}(Y).)

Note that forward_log_det_jacobian is the negative of this function, evaluated at g^{-1}(y).

Args:

y: Tensor. The input to the 'inverse' Jacobian determinant evaluation.
event_ndims: Number of dimensions in the probabilistic events being transformed. Must be greater than or equal to self.inverse_min_event_ndims. The result is summed over the final dimensions to produce a scalar Jacobian determinant for each event, i.e. it has shape rank(y) - event_ndims dimensions.
name: The name to give this op.
**kwargs: Named arguments forwarded to subclass implementation.

Returns:

ildj: Tensor, if this bijector is injective. If not injective, returns the tuple of local log det Jacobians, log(det(Dg_i^{-1}(y))), where g_i is the restriction of g to the ith partition Di.

Raises:

TypeError: if self.dtype is specified and y.dtype is not self.dtype.
NotImplementedError: if _inverse_log_det_jacobian is not implemented.

`with_name_scope`

with_name_scope(
    cls,
    method
)

Decorator to automatically enter the module name scope.

class MyModule(tf.Module):
  @tf.Module.with_name_scope
  def __call__(self, x):
    if not hasattr(self, 'w'):
      self.w = tf.Variable(tf.random.normal([x.shape[1], 64]))
    return tf.matmul(x, self.w)

Using the above module would produce tf.Variables and tf.Tensors whose names included the module name:

mod = MyModule()
mod(tf.ones([8, 32]))
# ==> <tf.Tensor: ...>
mod.w
# ==> <tf.Variable ...'my_module/w:0'>

Args:

method: The method to wrap.

Returns:

The original method wrapped such that it enters the module's name scope.

tfp.bijectors.AffineScalar

Class AffineScalar

Examples:

__init__

Args:

Raises:

Properties

dtype

forward_min_event_ndims

graph_parents

inverse_min_event_ndims

is_constant_jacobian

Returns:

log_scale

name

name_scope

scale

shift

submodules

Returns:

trainable_variables

Returns:

validate_args

variables

Returns:

Methods

__call__

Args:

Returns:

Examples

forward

Args:

Returns:

Raises:

forward_event_shape

Args:

Returns:

forward_event_shape_tensor

Args:

Returns:

forward_log_det_jacobian

Args:

Returns:

Raises:

inverse

Args:

Returns:

Raises:

inverse_event_shape

Args:

Returns:

inverse_event_shape_tensor

Args:

Returns:

inverse_log_det_jacobian

Args:

Returns:

Raises:

with_name_scope

Args:

Returns:

Class `AffineScalar`

`init`

`dtype`

`forward_min_event_ndims`

`graph_parents`

`inverse_min_event_ndims`

`is_constant_jacobian`

`log_scale`

`name`

`name_scope`

`scale`

`shift`

`submodules`

`trainable_variables`

`validate_args`

`variables`

`call`

`forward`

`forward_event_shape`

`forward_event_shape_tensor`

`forward_log_det_jacobian`

`inverse`

`inverse_event_shape`

`inverse_event_shape_tensor`

`inverse_log_det_jacobian`

`with_name_scope`