# tfp.substrates.numpy.bijectors.AffineLinearOperator

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

Inherits From: `Bijector`

`shift` is a numeric `Tensor` and `scale` is a `LinearOperator`.

If `X` is a scalar then the forward transformation is: `scale * X + shift` where `*` denotes broadcasted elementwise product.

#### Example Use:

``````linalg = tf.linalg

x = [1., 2, 3]

shift = [-1., 0., 1]
diag = [1., 2, 3]
scale = tf.linalg.LinearOperatorDiag(diag)
affine = AffineLinearOperator(shift, scale)
# In this case, `forward` is equivalent to:
# y = scale @ x + shift
y = affine.forward(x)  # [0., 4, 10]

shift = [2., 3, 1]
tril = [[1., 0, 0],
[2, 1, 0],
[3, 2, 1]]
scale = tf.linalg.LinearOperatorLowerTriangular(tril)
affine = AffineLinearOperator(shift, scale)
# In this case, `forward` is equivalent to:
# np.squeeze(np.matmul(tril, np.expand_dims(x, -1)), -1) + shift
y = affine.forward(x)  # [3., 7, 11]
``````

`shift` Floating-point `Tensor`.
`scale` Subclass of `LinearOperator`. Represents the (batch) positive definite matrix `M` in `R^{k x k}`.
`adjoint` Python `bool` indicating whether to use the `scale` matrix as specified or its adjoint. Default value: `False`.
`validate_args` Python `bool` indicating whether arguments should be checked for correctness.
`name` Python `str` name given to ops managed by this object.

`TypeError` if `scale` is not a `LinearOperator`.
`TypeError` if `shift.dtype` does not match `scale.dtype`.
`ValueError` if not `scale.is_non_singular`.

`adjoint` `bool` indicating `scale` should be used as conjugate transpose.
`dtype`

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

Multipart bijectors return structured `ndims`, which indicates the expected structure of their inputs. Some multipart bijectors, notably Composites, may return structures of `None`.

`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.

Multipart bijectors return structured `event_ndims`, which indicates the expected structure of their outputs. Some multipart bijectors, notably Composites, may return structures of `None`.

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

`name` Returns the string name of this `Bijector`.
`parameters` Dictionary of parameters used to instantiate this `Bijector`.
`scale` The `scale` `LinearOperator` in `Y = scale @ X + shift`.
`shift` The `shift` `Tensor` in `Y = scale @ X + shift`.
`trainable_variables`

`validate_args` Returns True if Tensor arguments will be validated.
`variables`

## Methods

### `forward`

View source

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

Args
`x` `Tensor` (structure). The input to the 'forward' evaluation.
`name` The name to give this op.
`**kwargs` Named arguments forwarded to subclass implementation.

Returns
`Tensor` (structure).

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

### `forward_dtype`

View source

Returns the dtype returned by `forward` for the provided input.

### `forward_event_ndims`

View source

Returns the number of event dimensions produced by `forward`.

### `forward_event_shape`

View source

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` (structure) indicating event-portion shape passed into `forward` function.

Returns
`forward_event_shape_tensor` `TensorShape` (structure) indicating event-portion shape after applying `forward`. Possibly unknown.

### `forward_event_shape_tensor`

View source

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

Args
`input_shape` `Tensor`, `int32` vector (structure) indicating event-portion shape passed into `forward` function.
`name` name to give to the op

Returns
`forward_event_shape_tensor` `Tensor`, `int32` vector (structure) indicating event-portion shape after applying `forward`.

### `forward_log_det_jacobian`

View source

Returns both the forward_log_det_jacobian.

Args
`x` `Tensor` (structure). 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. Multipart bijectors require structured event_ndims, such that `rank(y[i]) - rank(event_ndims[i])` is the same for all elements `i` of the structured input. Furthermore, the first `event_ndims[i]` of each `x[i].shape` must be the same for all `i` (broadcasting is not allowed).
`name` The name to give this op.
`**kwargs` Named arguments forwarded to subclass implementation.

Returns
`Tensor` (structure), if this bijector is injective. If not injective this is not implemented.

Raises
`TypeError` if `y`'s dtype is incompatible with the expected output 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

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

Args
`y` `Tensor` (structure). The input to the 'inverse' evaluation.
`name` The name to give this op.
`**kwargs` Named arguments forwarded to subclass implementation.

Returns
`Tensor` (structure), 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 `y`'s structured dtype is incompatible with the expected output dtype.
`NotImplementedError` if `_inverse` is not implemented.

### `inverse_dtype`

View source

Returns the dtype returned by forward for the provided input.

### `inverse_event_ndims`

View source

Returns the number of event dimensions produced by `inverse`.

### `inverse_event_shape`

View source

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` (structure) indicating event-portion shape passed into `inverse` function.

Returns
`inverse_event_shape_tensor` `TensorShape` (structure) indicating event-portion shape after applying `inverse`. Possibly unknown.

### `inverse_event_shape_tensor`

View source

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

Args
`output_shape` `Tensor`, `int32` vector (structure) indicating event-portion shape passed into `inverse` function.
`name` name to give to the op

Returns
`inverse_event_shape_tensor` `Tensor`, `int32` vector (structure) indicating event-portion shape after applying `inverse`.

### `inverse_log_det_jacobian`

View source

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` (structure). 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. Multipart bijectors require structured event_ndims, such that `rank(y[i]) - rank(event_ndims[i])` is the same for all elements `i` of the structured input. Furthermore, the first `event_ndims[i]` of each `x[i].shape` must be the same for all `i` (broadcasting is not allowed).
`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 `x`'s dtype is incompatible with the expected inverse-dtype.
`NotImplementedError` if `_inverse_log_det_jacobian` is not implemented.

### `__call__`

View source

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:

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

Args
`value` A `tfd.Distribution`, `tfb.Bijector`, or a (structure of) `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 (structure of) `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.])
``````

### `__eq__`

View source

Return self==value.

### `__ne__`

View source

Return self!=value.