An extension to torch's Sequential that allows conditioning either as a second forward argument or `condition()`

A convenient wrapper around `PixelImage` and `SpectralImage` and `CorrelateColors` to make a learnable image. Args: *shape (int)

Basic recipe that iterates mutiple epochs over a dataset. That loop is instrumented through several configurable callbacks. Callbacks can han

Computes and stores the average and current value

A packed block with Conv-BatchNorm-ReLU and various operations to alter it. Args: in_channels (int): input channels out_chan

A one layer classification head, turning activations / features into class log probabilities. It initially contains an avgpool-flatten-l

Serve all the images contained in a directory and subdirectories without any labels and structure constraint. Args: root (str):

Quantization layer from *Neural Discrete Representation Learning* Args: embedding_dim (int): number of features along which to quant

r"""Implements AdaBelief algorithm. AdaBelief from `AdaBelief Optimizer: Adapting Stepsizes by the Belief in Observed Gradients <https://arxi

A wrapper around :func:`pytorch.nn.functional.interpolate` with bilinear mode.

Average by keeping the whole sum and number of elements of the data logged. Useful when the metrics come per batch and an accurate number for

Generator discovered in AutoGAN: Neural Architecture Search for Generative Adversarial Networks. Args: arch (list): architecture

Implements Lookahead from `Lookahead Optimizer: k steps forward, 1 step back` (Zhang et al, 2019) Args: base_optimizer (Optimize

Transform an image with multiple transforms Args: transforms (list of transforms): the parallel set of transforms

r"""Implements RAdamW algorithm. RAdam from `On the Variance of the Adaptive Learning Rate and Beyond <https://arxiv.org/abs/1908.03265v1>`_

A Squeeze-And-Excite block Args: in_ch (int): input channels reduction (int): channels reduction factor for the hidden numbe

Construct a VGG-like model. The architecture is composed of either the number of channels or 'M' for a maxpool operation. This creates a

A block of the generator discovered by AutoGAN. Args: in_ch (int): number of input channels out_ch (int): number of output c

Wrap a dataset. Lazily caches *in RAM* elements returned by the underlying dataset. Args: ds (Dataset): A dataset transf

r"""Optimizer used by Deep Dream. It rescales the gradient by the average of the absolute values of the gradient. :math:`\theta_i := \theta_i

Normalize images channels as torchvision models expects, in a differentiable way

Style Transfer loss by Leon Gatys https://arxiv.org/abs/1508.06576 set the style and content before performing a forward pass.

Make a VGG16 with appropriately named layers that records intermediate activations. Args: layers (list of str): the names of the

UNet generator from Pix2Pix. Dropout layers have been substitued with Noise injections from StyleGAN2. Args: arch (List[int]): t

Residual generator used in `Pix2PixHD <https://arxiv.org/abs/1711.11585>`_ . :code:`arch` is a list of strings representing blocks.

A learnable image parameterized by its pixel values Args: shape (tuple of int): a tuple like (channels, height, width) sd (f

A learnable image parameterized by its Fourier representation. See https://distill.pub/2018/differentiable-parameterizations/ Implement

Average a window containing the `k` previous logged values Args: k (int): the window's length

Adaptive InstanceNormalization from `*Arbitrary Style Transfer in Real-time with Adaptive Instance Normalization* (Huang et al, 2017) <ht

Pad an input image so that it reaches size `size` Args: sz ((int, int)): target size padding_mode (str): one of the modes of

Define a customizable sequence of code blocks.

Takes an learnable image and applies the inverse color decorrelation from ImageNet (ie, it correlates the color like ImageNet to ease optimiz

Deep Dream recipe First instantiate the recipe then call `recipe(n_iter, img)` Args: model (nn.Module): the trained model to us

The Deep Dream loss Args: model (nn.Module): a pretrained network on which to compute the activations dream_laye

r""" Keep an exponentially decaying average of the values according to :math:`y := \beta y + (1 - \beta) x` Args: beta (float):

Feature viz First instantiate the recipe then call `recipe(n_iter, img)` Args: model (nn.Module): the trained model to use

Hourglass model from Deep Image Prior.

A masked 2D convolution for PixelCNN Args: in_chan (int): number of input channels out_chan (int): number of output channels

Linearly mixes two samples and labels from a dataset according to the MixUp algorithm https://arxiv.org/abs/1905.02249 Args:

Neural Style Recipe First instantiate the recipe then call `recipe(n_iter, img)` Args: device (device): where to run the comput

Add gaussian noise to the input, with a per channel or global learnable std. Args: ch (int): number of input channels for a differen

A PixelCNN model with 6 blocks Args: hid (int): the number of hidden channels in the blocks sz ((int, int)): the size of the

A Spade ResBlock from `Semantic Image Synthesis with Spatially-Adaptive Normalization` https://arxiv.org/abs/1903.07291

Randomly subsample images. Args: p (float): the transform is applied with probability p max_ratio (int): maximum subscaling

U-Net from `U-Net: Convolutional Networks for Biomedical Image Segmentation <https://arxiv.org/abs/1505.04597>`_. This net has architectural

Uniform sampler. Args: low (float): lower bound high (float): higher bound

r"""AddSign optimizer from Neural Optimiser search with Reinforcment learning (Bello et al, 2017) :math:`\theta_i := \theta_i - \text{lr}(1+\

From https://arxiv.org/abs/1908.01259

Attention56 bone Args: in_ch (int): number of channels in the images

Run Canny edge detector over an image. Requires OpenCV to be installed Args: thresh_low (int): lower threshold (default: 100)

A dataset of precedurally generated images of columns randomly colorized. Args: *size (int): size of images transform (trans

A dataset of precedurally generated images of rows randomly colorized. Args: *size (int): size of images transform (transfor

Cross Entropy loss accepting continuous target values See :func:`torchelie.loss.continuous_cross_entropy` for details.

Allow to pre-specify learning rate and momentum changes Args: optimizer (torch.optim.Optimizer): the optimizer to schedule. Currentl

Allow to pre-specify learning rate and momentum changes Args: optimizer (torch.optim.Optimizer): the optimizer to schedule. Currentl

Applies a random Cutout filter erasing at most :code:`max_size*100`% of the picture. Args: max_size (float): the maximum ratio t

An pass-through layer that prints some debug info during forward pass. It prints its name, the input's shape, mean of channels means, mean,

Wrap a module to eval model, can't be turned back to training mode, and make it invisible to recursive calls on `nn.Module`s Args:

Feature-wise Linear Modulation from https://distill.pub/2018/feature-wise-transformations/ The difference with AdaIN is that FiLM does no

The focal loss https://arxiv.org/abs/1708.02002 See :func:`torchelie.loss.focal_loss` for details.

Wrap a module to eval model, can't be turned back to training mode Args: m (nn.Module): a module