class

Transform

Transform()

source edit

Abstract bijection between two measurable spaces.

A Transform represents an invertible map $T : \mathcal{X} \to \mathcal{Y}$ together with its log-absolute-determinant Jacobian, used to push a base distribution through a measurable bijection. Composed with a base distribution via TransformedDistribution, it implements normalising flows, coupling layers, and standard change-of-variable arguments.

The change-of-variable formula for densities is

\log p_Y(\mathbf{y}) = \log p_X(\mathbf{x}) - \log \left|\det \frac{\partial T(\mathbf{x})}{\partial \mathbf{x}}\right|, \quad \mathbf{y} = T(\mathbf{x})

so the per-transform Jacobian determinant must be tractable.

Subclasses must override:

_call — forward map $\mathbf{y} = T(\mathbf{x})$ .
_inverse — inverse map $\mathbf{x} = T^{-1}(\mathbf{y})$ .
log_abs_det_jacobian — $\log \bigl|\det \partial T / \partial \mathbf{x}\bigr|$ , broadcast over the batch dimensions of the input.

Attributes

bijectivebool

True if the transform is invertible (most are; notable exception: AbsTransform).

signint

+1

for monotone-increasing scalar bijections,

-1

for monotone-decreasing. Used by the change-of-variable machinery to track CDF orientation.

event_dimint

Number of trailing tensor dimensions that the transform treats as a single event. 0 for element-wise maps,

\geq 1

for vector / matrix transforms (e.g. SoftmaxTransform has event_dim = 1, LowerCholeskyTransform has event_dim = 2).

Notes

Composition and inversion are provided structurally:

ComposeTransform — $T = T_n \circ \cdots \circ T_1$ .
~transform / inv — lazy _InverseTransform view.

so users can build complex bijectors without manually tracking Jacobian terms.

Examples

>>> import lucid
>>> from lucid.distributions.transforms import ExpTransform, AffineTransform, ComposeTransform
>>> # y = exp(2*x + 1) — a log-normal-like transform
>>> T = ComposeTransform([AffineTransform(loc=1.0, scale=2.0), ExpTransform()])
>>> x = lucid.tensor(0.0)
>>> y = T(x)
>>> T.log_abs_det_jacobian(x, y)
Tensor(...)

Used by 1

lucid.distributions

Constructors

dunder

init

→None

__init__()

source edit

Initialise the transform with an empty inverse cache.

dunder

call

→Tensor

__call__(x: Tensor)

source edit

Apply the forward map T(x) by delegating to _call.

Properties

prop

inv

→Transform

inv: Transform

source edit

Lazy inverse — caches an _InverseTransform view.

Instance methods

log_abs_det_jacobian

→Tensor

log_abs_det_jacobian(x: Tensor, y: Tensor)

source edit

Log-absolute-determinant of the Jacobian $\partial T / \partial x$ .

Subclasses must override and return $\log|\det \partial y / \partial x|$ broadcast over the input batch dimensions.

Parameters

xTensor

Pre-transform input.

yTensor

Post-transform output (typically y = self(x)). Some transforms can compute the log-Jacobian in terms of y more cheaply than x, hence both are required.

Returns

Tensor

Element-wise log-absolute-Jacobian-determinant, broadcastable to x.shape.

Dunder methods

dunder

repr

→str

__repr__()

source edit

Return a developer-facing string representation of the instance.

>>> import lucid >>> from lucid.distributions.transforms import ExpTransform, AffineTransform, ComposeTransform >>> # y = exp(2*x + 1) — a log-normal-like transform >>> T = ComposeTransform([AffineTransform(loc=1.0, scale=2.0), ExpTransform()]) >>> x = lucid.tensor(0.0) >>> y = T(x) >>> T.log_abs_det_jacobian(x, y) Tensor(...)