anomalib.models.components.freia

Framework for Easily Invertible Architectures.

Module to construct invertible networks with pytorch, based on a graph structure of operations.

Link to the original repo: https://github.com/VLL-HD/FrEIA

Subpackages

Package Contents

Classes

SequenceINN

Simpler than FrEIA.framework.GraphINN.

AllInOneBlock

Module combining the most common operations in a normalizing flow or similar model.
class anomalib.models.components.freia.SequenceINN(*dims: int, force_tuple_output=False)

Bases: anomalib.models.components.freia.modules.base.InvertibleModule

Simpler than FrEIA.framework.GraphINN.

Only supports a sequential series of modules (no splitting, merging, branching off). Has an append() method, to add new blocks in a more simple way than the computation-graph based approach of GraphINN. For example: .. code-block:: python

inn = SequenceINN(channels, dims_H, dims_W) for i in range(n_blocks):

inn.append(FrEIA.modules.AllInOneBlock, clamp=2.0, permute_soft=True)

inn.append(FrEIA.modules.HaarDownsampling) # and so on

append(module_class, cond=None, cond_shape=None, **kwargs)

Append a reversible block from FrEIA.modules to the network.

Parameters

  • module_class – Class from FrEIA.modules.

  • cond (int) – index of which condition to use (conditions will be passed as list to forward()). Conditioning nodes are not needed for SequenceINN.

  • cond_shape (tuple[int]) – the shape of the condition tensor.

  • **kwargs – Further keyword arguments that are passed to the constructor of module_class (see example).

__getitem__(item)

Get item.

__len__()

Get length.

__iter__()

Iter.

output_dims(input_dims: List[Tuple[int]]) → List[Tuple[int]]

Output Dims.

forward(x_or_z: torch.Tensor, c: Iterable[torch.Tensor] = None, rev: bool = False, jac: bool = True) → Tuple[torch.Tensor, torch.Tensor]

Execute the sequential INN in forward or inverse (rev=True) direction.

Parameters

  • x_or_z – input tensor (in contrast to GraphINN, a list of tensors is not supported, as SequenceINN only has one input).

  • c – list of conditions.

  • rev – whether to compute the network forward or reversed.

  • jac – whether to compute the log jacobian

Returns

network output. jac (Tensor): log-jacobian-determinant.

Return type

z_or_x (Tensor)

class anomalib.models.components.freia.AllInOneBlock(dims_in, dims_c=[], subnet_constructor: Callable = None, affine_clamping: float = 2.0, gin_block: bool = False, global_affine_init: float = 1.0, global_affine_type: str = 'SOFTPLUS', permute_soft: bool = False, learned_householder_permutation: int = 0, reverse_permutation: bool = False)

Bases: anomalib.models.components.freia.modules.base.InvertibleModule

Module combining the most common operations in a normalizing flow or similar model.

It combines affine coupling, permutation, and global affine transformation (‘ActNorm’). It can also be used as GIN coupling block, perform learned householder permutations, and use an inverted pre-permutation. The affine transformation includes a soft clamping mechanism, first used in Real-NVP. The block as a whole performs the following computation: .. math:

y = V\\,R \\; \\Psi(s_\\mathrm{global}) \\odot \\mathrm{Coupling}\\Big(R^{-1} V^{-1} x\\Big)+ t_\\mathrm{global}

  • The inverse pre-permutation of x (i.e. \(R^{-1} V^{-1}\)) is optional (see reverse_permutation below).

  • The learned householder reflection matrix \(V\) is also optional all together (see learned_householder_permutation below).

  • For the coupling, the input is split into \(x_1, x_2\) along the channel dimension. Then the output of the coupling operation is the two halves \(u = \\mathrm{concat}(u_1, u_2)\). .. math:

    u_1 &= x_1 \\odot \\exp \\Big( \\alpha \\; \\mathrm{tanh}\\big( s(x_2) \\big)\\Big) + t(x_2) \\\\
u_2 &= x_2

    Because \(\\mathrm{tanh}(s) \\in [-1, 1]\), this clamping mechanism prevents exploding values in the exponential. The hyperparameter \(\\alpha\) can be adjusted.

_construct_householder_permutation()

Compute a permutation matrix.

Compute a permutation matrix from the reflection vectors that are learned internally as nn.Parameters.

_permute(x, rev=False)

Perform permutation.

Performs the permutation and scaling after the coupling operation. Returns transformed outputs and the LogJacDet of the scaling operation.

_pre_permute(x, rev=False)

Permute before the coupling block, only used if reverse_permutation is set.

_affine(x, a, rev=False)

Perform affine coupling operation.

Given the passive half, and the pre-activation outputs of the coupling subnetwork, perform the affine coupling operation. Returns both the transformed inputs and the LogJacDet.

forward(x, c=[], rev=False, jac=True)

See base class docstring.

output_dims(input_dims)

Output Dims.