configuration_factories

Convenience functions to create configurations for training and inference.

`algorithm_factory(algorithm)` #

Create an algorithm model for training CAREamics.

Parameters:

Name	Type	Description	Default
`algorithm`	`dict`	Algorithm dictionary.	required

Returns:

Type	Description
`N2VAlgorithm or N2NAlgorithm or CAREAlgorithm or PN2VAlgorithm`	Algorithm model for training CAREamics.

Source code in src/careamics/config/configuration_factories.py

def algorithm_factory(
    algorithm: dict[str, Any],
) -> Union[N2VAlgorithm, N2NAlgorithm, CAREAlgorithm, PN2VAlgorithm]:
    """
    Create an algorithm model for training CAREamics.

    Parameters
    ----------
    algorithm : dict
        Algorithm dictionary.

    Returns
    -------
    N2VAlgorithm or N2NAlgorithm or CAREAlgorithm or PN2VAlgorithm
        Algorithm model for training CAREamics.
    """
    adapter: TypeAdapter = TypeAdapter(
        Annotated[
            Union[N2VAlgorithm, N2NAlgorithm, CAREAlgorithm, PN2VAlgorithm],
            Field(discriminator="algorithm"),
        ]
    )
    return adapter.validate_python(algorithm)

`create_care_configuration(experiment_name, data_type, axes, patch_size, batch_size, num_epochs=100, num_steps=None, augmentations=None, independent_channels=True, loss='mae', n_channels_in=None, n_channels_out=None, logger='none', trainer_params=None, model_params=None, optimizer='Adam', optimizer_params=None, lr_scheduler='ReduceLROnPlateau', lr_scheduler_params=None, train_dataloader_params=None, val_dataloader_params=None, checkpoint_params=None)` #

Create a configuration for training CARE.

If "Z" is present in axes, then patch_size must be a list of length 3, otherwise 2.

If "C" is present in axes, then you need to set n_channels_in to the number of channels. Likewise, if you set the number of channels, then "C" must be present in axes.

To set the number of output channels, use the n_channels_out parameter. If it is not specified, it will be assumed to be equal to n_channels_in.

By default, all channels are trained together. To train all channels independently, set independent_channels to True.

By setting augmentations to None, the default transformations (flip in X and Y, rotations by 90 degrees in the XY plane) are applied. Rather than the default transforms, a list of transforms can be passed to the augmentations parameter. To disable the transforms, simply pass an empty list.

Parameters:

Name	Type	Description	Default
`experiment_name`	`str`	Name of the experiment.	required
`data_type`	`Literal['array', 'tiff', 'czi', 'custom']`	Type of the data.	required
`axes`	`str`	Axes of the data (e.g. SYX).	required
`patch_size`	`List[int]`	Size of the patches along the spatial dimensions (e.g. [64, 64]).	required
`batch_size`	`int`	Batch size.	required
`num_epochs`	`int`	Number of epochs to train for. If provided, this will be added to trainer_params.	`100`
`num_steps`	`int`	Number of batches in 1 epoch. If provided, this will be added to trainer_params. Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant documentation for more details.	`None`
`augmentations`	`list of transforms`	List of transforms to apply, either both or one of XYFlipConfig and XYRandomRotate90Config. By default, it applies both XYFlip (on X and Y) and XYRandomRotate90 (in XY) to the images.	`None`
`independent_channels`	`bool`	Whether to train all channels independently, by default False.	`True`
`loss`	`Literal['mae', 'mse']`	Loss function to use.	`"mae"`
`n_channels_in`	`int or None`	Number of channels in.	`None`
`n_channels_out`	`int or None`	Number of channels out.	`None`
`logger`	`Literal['wandb', 'tensorboard', 'none']`	Logger to use.	`"none"`
`trainer_params`	`dict`	Parameters for the trainer class, see PyTorch Lightning documentation.	`None`
`model_params`	`dict`	UNetModel parameters.	`None`
`optimizer`	`Literal['Adam', 'Adamax', 'SGD']`	Optimizer to use.	`"Adam"`
`optimizer_params`	`dict`	Parameters for the optimizer, see PyTorch documentation for more details.	`None`
`lr_scheduler`	`Literal['ReduceLROnPlateau', 'StepLR']`	Learning rate scheduler to use.	`"ReduceLROnPlateau"`
`lr_scheduler_params`	`dict`	Parameters for the learning rate scheduler, see PyTorch documentation for more details.	`None`
`train_dataloader_params`	`dict`	Parameters for the training dataloader, see the PyTorch docs for `DataLoader`. If left as `None`, the dict `{"shuffle": True}` will be used, this is set in the `GeneralDataConfig`.	`None`
`val_dataloader_params`	`dict`	Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`. If left as `None`, the empty dict `{}` will be used, this is set in the `GeneralDataConfig`.	`None`
`checkpoint_params`	`dict`	Parameters for the checkpoint callback, see PyTorch Lightning documentation (`ModelCheckpoint`) for the list of available parameters.	`None`

Returns:

Type	Description
`Configuration`	Configuration for training CARE.

Examples:

Minimum example:

>>> config = create_care_configuration(
...     experiment_name="care_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100
... )

You can also limit the number of batches per epoch:

>>> config = create_care_configuration(
...     experiment_name="care_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_steps=100  # limit to 100 batches per epoch
... )

To disable transforms, simply set augmentations to an empty list:

>>> config = create_care_configuration(
...     experiment_name="care_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     augmentations=[]
... )

A list of transforms can be passed to the augmentations parameter to replace the default augmentations:

>>> from careamics.config.transformations import XYFlipConfig
>>> config = create_care_configuration(
...     experiment_name="care_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     augmentations=[
...         # No rotation and only Y flipping
...         XYFlipConfig(flip_x = False, flip_y = True)
...     ]
... )

If you are training multiple channels they will be trained independently by default, you simply need to specify the number of channels input (and optionally, the number of channels output):

>>> config = create_care_configuration(
...     experiment_name="care_experiment",
...     data_type="array",
...     axes="YXC", # channels must be in the axes
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     n_channels_in=3, # number of input channels
...     n_channels_out=1 # if applicable
... )

If instead you want to train multiple channels together, you need to turn off the independent_channels parameter:

>>> config = create_care_configuration(
...     experiment_name="care_experiment",
...     data_type="array",
...     axes="YXC", # channels must be in the axes
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     independent_channels=False,
...     n_channels_in=3,
...     n_channels_out=1 # if applicable
... )

If you would like to train on CZI files, use "czi" as data_type and "SCYX" as axes for 2-D or "SCZYX" for 3-D denoising. Note that "SCYX" can also be used for 3-D data but spatial context along the Z dimension will then not be taken into account.

>>> config_2d = create_care_configuration(
...     experiment_name="care_experiment",
...     data_type="czi",
...     axes="SCYX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     n_channels_in=1,
... )
>>> config_3d = create_care_configuration(
...     experiment_name="care_experiment",
...     data_type="czi",
...     axes="SCZYX",
...     patch_size=[16, 64, 64],
...     batch_size=16,
...     num_epochs=100,
...     n_channels_in=1,
... )

Source code in src/careamics/config/configuration_factories.py

def create_care_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    num_epochs: int = 100,
    num_steps: int | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    independent_channels: bool = True,
    loss: Literal["mae", "mse"] = "mae",
    n_channels_in: int | None = None,
    n_channels_out: int | None = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    trainer_params: dict | None = None,
    model_params: dict | None = None,
    optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
    optimizer_params: dict[str, Any] | None = None,
    lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
    lr_scheduler_params: dict[str, Any] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
    checkpoint_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training CARE.

    If "Z" is present in `axes`, then `patch_size` must be a list of length 3, otherwise
    2.

    If "C" is present in `axes`, then you need to set `n_channels_in` to the number of
    channels. Likewise, if you set the number of channels, then "C" must be present in
    `axes`.

    To set the number of output channels, use the `n_channels_out` parameter. If it is
    not specified, it will be assumed to be equal to `n_channels_in`.

    By default, all channels are trained together. To train all channels independently,
    set `independent_channels` to True.

    By setting `augmentations` to `None`, the default transformations (flip in X and Y,
    rotations by 90 degrees in the XY plane) are applied. Rather than the default
    transforms, a list of transforms can be passed to the `augmentations` parameter. To
    disable the transforms, simply pass an empty list.

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "czi", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    augmentations : list of transforms, default=None
        List of transforms to apply, either both or one of XYFlipConfig and
        XYRandomRotate90Config. By default, it applies both XYFlip (on X and Y)
        and XYRandomRotate90 (in XY) to the images.
    independent_channels : bool, optional
        Whether to train all channels independently, by default False.
    loss : Literal["mae", "mse"], default="mae"
        Loss function to use.
    n_channels_in : int or None, default=None
        Number of channels in.
    n_channels_out : int or None, default=None
        Number of channels out.
    logger : Literal["wandb", "tensorboard", "none"], default="none"
        Logger to use.
    trainer_params : dict, optional
        Parameters for the trainer class, see PyTorch Lightning documentation.
    model_params : dict, default=None
        UNetModel parameters.
    optimizer : Literal["Adam", "Adamax", "SGD"], default="Adam"
        Optimizer to use.
    optimizer_params : dict, default=None
        Parameters for the optimizer, see PyTorch documentation for more details.
    lr_scheduler : Literal["ReduceLROnPlateau", "StepLR"], default="ReduceLROnPlateau"
        Learning rate scheduler to use.
    lr_scheduler_params : dict, default=None
        Parameters for the learning rate scheduler, see PyTorch documentation for more
        details.
    train_dataloader_params : dict, optional
        Parameters for the training dataloader, see the PyTorch docs for `DataLoader`.
        If left as `None`, the dict `{"shuffle": True}` will be used, this is set in
        the `GeneralDataConfig`.
    val_dataloader_params : dict, optional
        Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`.
        If left as `None`, the empty dict `{}` will be used, this is set in the
        `GeneralDataConfig`.
    checkpoint_params : dict, default=None
        Parameters for the checkpoint callback, see PyTorch Lightning documentation
        (`ModelCheckpoint`) for the list of available parameters.

    Returns
    -------
    Configuration
        Configuration for training CARE.

    Examples
    --------
    Minimum example:
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100
    ... )

    You can also limit the number of batches per epoch:
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_steps=100  # limit to 100 batches per epoch
    ... )

    To disable transforms, simply set `augmentations` to an empty list:
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[]
    ... )

    A list of transforms can be passed to the `augmentations` parameter to replace the
    default augmentations:
    >>> from careamics.config.transformations import XYFlipConfig
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[
    ...         # No rotation and only Y flipping
    ...         XYFlipConfig(flip_x = False, flip_y = True)
    ...     ]
    ... )

    If you are training multiple channels they will be trained independently by default,
    you simply need to specify the number of channels input (and optionally, the number
    of channels output):
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YXC", # channels must be in the axes
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels_in=3, # number of input channels
    ...     n_channels_out=1 # if applicable
    ... )

    If instead you want to train multiple channels together, you need to turn off the
    `independent_channels` parameter:
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YXC", # channels must be in the axes
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     independent_channels=False,
    ...     n_channels_in=3,
    ...     n_channels_out=1 # if applicable
    ... )

    If you would like to train on CZI files, use `"czi"` as `data_type` and `"SCYX"` as
    `axes` for 2-D or `"SCZYX"` for 3-D denoising. Note that `"SCYX"` can also be used
    for 3-D data but spatial context along the Z dimension will then not be taken into
    account.
    >>> config_2d = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="czi",
    ...     axes="SCYX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels_in=1,
    ... )
    >>> config_3d = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="czi",
    ...     axes="SCZYX",
    ...     patch_size=[16, 64, 64],
    ...     batch_size=16,
    ...     num_epochs=100,
    ...     n_channels_in=1,
    ... )
    """
    return Configuration(
        **_create_supervised_config_dict(
            algorithm="care",
            experiment_name=experiment_name,
            data_type=data_type,
            axes=axes,
            patch_size=patch_size,
            batch_size=batch_size,
            augmentations=augmentations,
            independent_channels=independent_channels,
            loss=loss,
            n_channels_in=n_channels_in,
            n_channels_out=n_channels_out,
            logger=logger,
            trainer_params=trainer_params,
            model_params=model_params,
            optimizer=optimizer,
            optimizer_params=optimizer_params,
            lr_scheduler=lr_scheduler,
            lr_scheduler_params=lr_scheduler_params,
            train_dataloader_params=train_dataloader_params,
            val_dataloader_params=val_dataloader_params,
            checkpoint_params=checkpoint_params,
            num_epochs=num_epochs,
            num_steps=num_steps,
        )
    )

create_hdn_configuration(experiment_name, data_type, axes, patch_size, batch_size, num_epochs=100, num_steps=None, encoder_conv_strides=(2, 2), decoder_conv_strides=(2, 2), multiscale_count=1, z_dims=(128, 128), output_channels=1, encoder_n_filters=32, decoder_n_filters=32, encoder_dropout=0.0, decoder_dropout=0.0, nonlinearity='ReLU', analytical_kl=False, predict_logvar=None, logvar_lowerbound=None, logger='none', trainer_params=None, augmentations=None, train_dataloader_params=None, val_dataloader_params=None) #

Create a configuration for training HDN.

If "Z" is present in axes, then patch_size must be a list of length 3, otherwise 2.

If "C" is present in axes, then you need to set n_channels_in to the number of channels. Likewise, if you set the number of channels, then "C" must be present in axes.

To set the number of output channels, use the n_channels_out parameter. If it is not specified, it will be assumed to be equal to n_channels_in.

By default, all channels are trained independently. To train all channels together, set independent_channels to False.

By setting augmentations to None, the default transformations (flip in X and Y, rotations by 90 degrees in the XY plane) are applied. Rather than the default transforms, a list of transforms can be passed to the augmentations parameter. To disable the transforms, simply pass an empty list.

TODO revisit the necessity of model_params#

Parameters:

Name	Type	Description	Default
`experiment_name`	`str`	Name of the experiment.	required
`data_type`	`Literal['array', 'tiff', 'custom']`	Type of the data.	required
`axes`	`str`	Axes of the data (e.g. SYX).	required
`patch_size`	`List[int]`	Size of the patches along the spatial dimensions (e.g. [64, 64]).	required
`batch_size`	`int`	Batch size.	required
`num_epochs`	`int`	Number of epochs to train for. If provided, this will be added to trainer_params.	`100`
`num_steps`	`int`	Number of batches in 1 epoch. If provided, this will be added to trainer_params. Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant documentation for more details.	`None`
`encoder_conv_strides`	`tuple[int, ...]`	Strides for the encoder convolutional layers, by default (2, 2).	`(2, 2)`
`decoder_conv_strides`	`tuple[int, ...]`	Strides for the decoder convolutional layers, by default (2, 2).	`(2, 2)`
`multiscale_count`	`int`	Number of scales in the multiscale architecture, by default 1.	`1`
`z_dims`	`tuple[int, ...]`	Dimensions of the latent space, by default (128, 128).	`(128, 128)`
`output_channels`	`int`	Number of output channels, by default 1.	`1`
`encoder_n_filters`	`int`	Number of filters in the encoder, by default 32.	`32`
`decoder_n_filters`	`int`	Number of filters in the decoder, by default 32.	`32`
`encoder_dropout`	`float`	Dropout rate for the encoder, by default 0.0.	`0.0`
`decoder_dropout`	`float`	Dropout rate for the decoder, by default 0.0.	`0.0`
`nonlinearity`	`Literal`	Nonlinearity function to use, by default "ReLU".	`'ReLU'`
`analytical_kl`	`bool`	Whether to use analytical KL divergence, by default False.	`False`
`predict_logvar`	`Literal[None, 'pixelwise']`	Type of log variance prediction, by default None.	`None`
`logvar_lowerbound`	`Union[float, None]`	Lower bound for the log variance, by default None.	`None`
`logger`	`Literal['wandb', 'tensorboard', 'none']`	Logger to use for training, by default "none".	`'none'`
`trainer_params`	`dict`	Parameters for the trainer class, see PyTorch Lightning documentation.	`None`
`augmentations`	`list[XYFlipConfig \| XYRandomRotate90Config] \| None`	List of augmentations to apply, by default None.	`None`
`train_dataloader_params`	`Optional[dict[str, Any]]`	Parameters for the training dataloader, by default None.	`None`
`val_dataloader_params`	`Optional[dict[str, Any]]`	Parameters for the validation dataloader, by default None.	`None`

Returns:

Type	Description
`Configuration`	The configuration object for training HDN.

Examples:

Minimum example:

>>> config = create_hdn_configuration(
...     experiment_name="hdn_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100
... )

You can also limit the number of batches per epoch:

>>> config = create_hdn_configuration(
...     experiment_name="hdn_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_steps=100  # limit to 100 batches per epoch
... )

Source code in src/careamics/config/configuration_factories.py

def create_hdn_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    num_epochs: int = 100,
    num_steps: int | None = None,
    encoder_conv_strides: tuple[int, ...] = (2, 2),
    decoder_conv_strides: tuple[int, ...] = (2, 2),
    multiscale_count: int = 1,
    z_dims: tuple[int, ...] = (128, 128),
    output_channels: int = 1,
    encoder_n_filters: int = 32,
    decoder_n_filters: int = 32,
    encoder_dropout: float = 0.0,
    decoder_dropout: float = 0.0,
    nonlinearity: Literal[
        "None", "Sigmoid", "Softmax", "Tanh", "ReLU", "LeakyReLU", "ELU"
    ] = "ReLU",
    analytical_kl: bool = False,
    predict_logvar: Literal["pixelwise"] | None = None,
    logvar_lowerbound: Union[float, None] = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    trainer_params: dict | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training HDN.

    If "Z" is present in `axes`, then `patch_size` must be a list of length 3, otherwise
    2.

    If "C" is present in `axes`, then you need to set `n_channels_in` to the number of
    channels. Likewise, if you set the number of channels, then "C" must be present in
    `axes`.

    To set the number of output channels, use the `n_channels_out` parameter. If it is
    not specified, it will be assumed to be equal to `n_channels_in`.

    By default, all channels are trained independently. To train all channels together,
    set `independent_channels` to False.

    By setting `augmentations` to `None`, the default transformations (flip in X and Y,
    rotations by 90 degrees in the XY plane) are applied. Rather than the default
    transforms, a list of transforms can be passed to the `augmentations` parameter. To
    disable the transforms, simply pass an empty list.

    # TODO revisit the necessity of model_params

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    encoder_conv_strides : tuple[int, ...], optional
        Strides for the encoder convolutional layers, by default (2, 2).
    decoder_conv_strides : tuple[int, ...], optional
        Strides for the decoder convolutional layers, by default (2, 2).
    multiscale_count : int, optional
        Number of scales in the multiscale architecture, by default 1.
    z_dims : tuple[int, ...], optional
        Dimensions of the latent space, by default (128, 128).
    output_channels : int, optional
        Number of output channels, by default 1.
    encoder_n_filters : int, optional
        Number of filters in the encoder, by default 32.
    decoder_n_filters : int, optional
        Number of filters in the decoder, by default 32.
    encoder_dropout : float, optional
        Dropout rate for the encoder, by default 0.0.
    decoder_dropout : float, optional
        Dropout rate for the decoder, by default 0.0.
    nonlinearity : Literal, optional
        Nonlinearity function to use, by default "ReLU".
    analytical_kl : bool, optional
        Whether to use analytical KL divergence, by default False.
    predict_logvar : Literal[None, "pixelwise"], optional
        Type of log variance prediction, by default None.
    logvar_lowerbound : Union[float, None], optional
        Lower bound for the log variance, by default None.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use for training, by default "none".
    trainer_params : dict, optional
        Parameters for the trainer class, see PyTorch Lightning documentation.
    augmentations : list[XYFlipConfig | XYRandomRotate90Config] | None, optional
        List of augmentations to apply, by default None.
    train_dataloader_params : Optional[dict[str, Any]], optional
        Parameters for the training dataloader, by default None.
    val_dataloader_params : Optional[dict[str, Any]], optional
        Parameters for the validation dataloader, by default None.

    Returns
    -------
    Configuration
        The configuration object for training HDN.

    Examples
    --------
    Minimum example:
    >>> config = create_hdn_configuration(
    ...     experiment_name="hdn_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100
    ... )

    You can also limit the number of batches per epoch:
    >>> config = create_hdn_configuration(
    ...     experiment_name="hdn_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_steps=100  # limit to 100 batches per epoch
    ... )
    """
    transform_list = _list_spatial_augmentations(augmentations)

    loss_config = LVAELossConfig(
        loss_type="hdn", denoisplit_weight=1, musplit_weight=0
    )  # TODO what are the correct defaults for HDN?

    gaussian_likelihood = GaussianLikelihoodConfig(
        predict_logvar=predict_logvar, logvar_lowerbound=logvar_lowerbound
    )

    # algorithm & model
    algorithm_params = _create_vae_based_algorithm(
        algorithm="hdn",
        loss=loss_config,
        input_shape=patch_size,
        encoder_conv_strides=encoder_conv_strides,
        decoder_conv_strides=decoder_conv_strides,
        multiscale_count=multiscale_count,
        z_dims=z_dims,
        output_channels=output_channels,
        encoder_n_filters=encoder_n_filters,
        decoder_n_filters=decoder_n_filters,
        encoder_dropout=encoder_dropout,
        decoder_dropout=decoder_dropout,
        nonlinearity=nonlinearity,
        predict_logvar=predict_logvar,
        analytical_kl=analytical_kl,
        gaussian_likelihood=gaussian_likelihood,
        nm_likelihood=None,
    )

    # data
    data_params = _create_data_configuration(
        data_type=data_type,
        axes=axes,
        patch_size=patch_size,
        batch_size=batch_size,
        augmentations=transform_list,
        train_dataloader_params=train_dataloader_params,
        val_dataloader_params=val_dataloader_params,
    )

    # training
    final_trainer_params = update_trainer_params(
        trainer_params=trainer_params,
        num_epochs=num_epochs,
        num_steps=num_steps,
    )
    training_params = _create_training_configuration(
        trainer_params=final_trainer_params,
        logger=logger,
    )

    return Configuration(
        experiment_name=experiment_name,
        algorithm_config=algorithm_params,
        data_config=data_params,
        training_config=training_params,
    )

create_microsplit_configuration(experiment_name, data_type, axes, patch_size, batch_size, num_epochs=100, num_steps=None, encoder_conv_strides=(2, 2), decoder_conv_strides=(2, 2), multiscale_count=3, grid_size=32, z_dims=(128, 128), output_channels=1, encoder_n_filters=32, decoder_n_filters=32, encoder_dropout=0.0, decoder_dropout=0.0, nonlinearity='ReLU', analytical_kl=False, predict_logvar='pixelwise', logvar_lowerbound=None, logger='none', trainer_params=None, augmentations=None, nm_paths=None, data_stats=None, train_dataloader_params=None, val_dataloader_params=None) #

Create a configuration for training MicroSplit.

Parameters:

Name	Type	Description	Default
`experiment_name`	`str`	Name of the experiment.	required
`data_type`	`Literal['array', 'tiff', 'custom']`	Type of the data.	required
`axes`	`str`	Axes of the data (e.g. SYX).	required
`patch_size`	`Sequence[int]`	Size of the patches along the spatial dimensions (e.g. [64, 64]).	required
`batch_size`	`int`	Batch size.	required
`num_epochs`	`int`	Number of epochs to train for. If provided, this will be added to trainer_params.	`100`
`num_steps`	`int`	Number of batches in 1 epoch. If provided, this will be added to trainer_params. Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant documentation for more details.	`None`
`encoder_conv_strides`	`tuple[int, ...]`	Strides for the encoder convolutional layers, by default (2, 2).	`(2, 2)`
`decoder_conv_strides`	`tuple[int, ...]`	Strides for the decoder convolutional layers, by default (2, 2).	`(2, 2)`
`multiscale_count`	`int`	Number of multiscale levels, by default 3.	`3`
`grid_size`	`int`	Size of the grid for multiscale training, by default 32.	`32`
`z_dims`	`tuple[int, ...]`	List of latent dims for each hierarchy level in the LVAE, default (128, 128).	`(128, 128)`
`output_channels`	`int`	Number of output channels for the model, by default 1.	`1`
`encoder_n_filters`	`int`	Number of filters in the encoder, by default 32.	`32`
`decoder_n_filters`	`int`	Number of filters in the decoder, by default 32.	`32`
`encoder_dropout`	`float`	Dropout rate for the encoder, by default 0.0.	`0.0`
`decoder_dropout`	`float`	Dropout rate for the decoder, by default 0.0.	`0.0`
`nonlinearity`	`Literal`	Nonlinearity to use in the model, by default "ReLU".	`'ReLU'`
`analytical_kl`	`bool`	Whether to use analytical KL divergence, by default False.	`False`
`predict_logvar`	`Literal['pixelwise'] \| None`	Type of log-variance prediction, by default None.	`'pixelwise'`
`logvar_lowerbound`	`Union[float, None]`	Lower bound for the log variance, by default None.	`None`
`logger`	`Literal['wandb', 'tensorboard', 'none']`	Logger to use for training, by default "none".	`'none'`
`trainer_params`	`dict`	Parameters for the trainer class, see PyTorch Lightning documentation.	`None`
`augmentations`	`list[Union[XYFlipConfig, XYRandomRotate90Config]] \| None`	List of augmentations to apply, by default None.	`None`
`nm_paths`	`list[str] \| None`	Paths to the noise model files, by default None.	`None`
`data_stats`	`tuple[float, float] \| None`	Data statistics (mean, std), by default None.	`None`
`train_dataloader_params`	`dict[str, Any] \| None`	Parameters for the training dataloader, by default None.	`None`
`val_dataloader_params`	`dict[str, Any] \| None`	Parameters for the validation dataloader, by default None.	`None`

Returns:

Type	Description
`Configuration`	A configuration object for the microsplit algorithm.

Examples:

Minimum example:

>>> config = create_microsplit_configuration(#

... experiment_name="microsplit_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... num_epochs=100#

... )#

You can also limit the number of batches per epoch:#

>>> config = create_microsplit_configuration(#

... experiment_name="microsplit_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... num_steps=100 # limit to 100 batches per epoch#

... )#

Source code in src/careamics/config/configuration_factories.py

def create_microsplit_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    num_epochs: int = 100,
    num_steps: int | None = None,
    encoder_conv_strides: tuple[int, ...] = (2, 2),
    decoder_conv_strides: tuple[int, ...] = (2, 2),
    multiscale_count: int = 3,
    grid_size: int = 32,  # TODO most likely can be derived from patch size
    z_dims: tuple[int, ...] = (128, 128),
    output_channels: int = 1,
    encoder_n_filters: int = 32,
    decoder_n_filters: int = 32,
    encoder_dropout: float = 0.0,
    decoder_dropout: float = 0.0,
    nonlinearity: Literal[
        "None", "Sigmoid", "Softmax", "Tanh", "ReLU", "LeakyReLU", "ELU"
    ] = "ReLU",  # TODO do we need all these?
    analytical_kl: bool = False,
    predict_logvar: Literal["pixelwise"] = "pixelwise",
    logvar_lowerbound: Union[float, None] = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    trainer_params: dict | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    nm_paths: list[str] | None = None,
    data_stats: tuple[float, float] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training MicroSplit.

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : Sequence[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    encoder_conv_strides : tuple[int, ...], optional
        Strides for the encoder convolutional layers, by default (2, 2).
    decoder_conv_strides : tuple[int, ...], optional
        Strides for the decoder convolutional layers, by default (2, 2).
    multiscale_count : int, optional
        Number of multiscale levels, by default 3.
    grid_size : int, optional
        Size of the grid for multiscale training, by default 32.
    z_dims : tuple[int, ...], optional
        List of latent dims for each hierarchy level in the LVAE, default (128, 128).
    output_channels : int, optional
        Number of output channels for the model, by default 1.
    encoder_n_filters : int, optional
        Number of filters in the encoder, by default 32.
    decoder_n_filters : int, optional
        Number of filters in the decoder, by default 32.
    encoder_dropout : float, optional
        Dropout rate for the encoder, by default 0.0.
    decoder_dropout : float, optional
        Dropout rate for the decoder, by default 0.0.
    nonlinearity : Literal, optional
        Nonlinearity to use in the model, by default "ReLU".
    analytical_kl : bool, optional
        Whether to use analytical KL divergence, by default False.
    predict_logvar : Literal["pixelwise"] | None, optional
        Type of log-variance prediction, by default None.
    logvar_lowerbound : Union[float, None], optional
        Lower bound for the log variance, by default None.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use for training, by default "none".
    trainer_params : dict, optional
        Parameters for the trainer class, see PyTorch Lightning documentation.
    augmentations : list[Union[XYFlipConfig, XYRandomRotate90Config]] | None, optional
        List of augmentations to apply, by default None.
    nm_paths : list[str] | None, optional
        Paths to the noise model files, by default None.
    data_stats : tuple[float, float] | None, optional
        Data statistics (mean, std), by default None.
    train_dataloader_params : dict[str, Any] | None, optional
        Parameters for the training dataloader, by default None.
    val_dataloader_params : dict[str, Any] | None, optional
        Parameters for the validation dataloader, by default None.

    Returns
    -------
    Configuration
        A configuration object for the microsplit algorithm.

    Examples
    --------
    Minimum example:
    # >>> config = create_microsplit_configuration(
    # ...     experiment_name="microsplit_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     num_epochs=100

    # ... )

    # You can also limit the number of batches per epoch:
    # >>> config = create_microsplit_configuration(
    # ...     experiment_name="microsplit_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     num_steps=100  # limit to 100 batches per epoch
    # ... )
    """
    transform_list = _list_spatial_augmentations(augmentations)

    loss_config = LVAELossConfig(
        loss_type="denoisplit_musplit", denoisplit_weight=0.9, musplit_weight=0.1
    )  # TODO losses need to be refactored! just for example. Add validator if sum to 1

    # Create likelihood configurations
    gaussian_likelihood_config, noise_model_config, nm_likelihood_config = (
        get_likelihood_config(
            loss_type="denoisplit_musplit",
            predict_logvar=predict_logvar,
            logvar_lowerbound=logvar_lowerbound,
            nm_paths=nm_paths,
            data_stats=data_stats,
        )
    )

    # Create the LVAE model
    network_model = _create_vae_configuration(
        input_shape=patch_size,
        encoder_conv_strides=encoder_conv_strides,
        decoder_conv_strides=decoder_conv_strides,
        multiscale_count=multiscale_count,
        z_dims=z_dims,
        output_channels=output_channels,
        encoder_n_filters=encoder_n_filters,
        decoder_n_filters=decoder_n_filters,
        encoder_dropout=encoder_dropout,
        decoder_dropout=decoder_dropout,
        nonlinearity=nonlinearity,
        predict_logvar=predict_logvar,
        analytical_kl=analytical_kl,
    )

    # Create the MicroSplit algorithm configuration
    algorithm_params = {
        "algorithm": "microsplit",
        "loss": loss_config,
        "model": network_model,
        "gaussian_likelihood": gaussian_likelihood_config,
        "noise_model": noise_model_config,
        "noise_model_likelihood": nm_likelihood_config,
    }

    # Convert to MicroSplitAlgorithm instance
    algorithm_config = MicroSplitAlgorithm(**algorithm_params)

    # data
    data_params = _create_microsplit_data_configuration(
        data_type=data_type,
        axes=axes,
        patch_size=patch_size,
        grid_size=grid_size,
        multiscale_count=multiscale_count,
        batch_size=batch_size,
        augmentations=transform_list,
        train_dataloader_params=train_dataloader_params,
        val_dataloader_params=val_dataloader_params,
    )

    # training
    final_trainer_params = update_trainer_params(
        trainer_params=trainer_params,
        num_epochs=num_epochs,
        num_steps=num_steps,
    )
    training_params = _create_training_configuration(
        trainer_params=final_trainer_params,
        logger=logger,
    )

    return Configuration(
        experiment_name=experiment_name,
        algorithm_config=algorithm_config,
        data_config=data_params,
        training_config=training_params,
    )

`create_n2n_configuration(experiment_name, data_type, axes, patch_size, batch_size, num_epochs=100, num_steps=None, augmentations=None, independent_channels=True, loss='mae', n_channels_in=None, n_channels_out=None, logger='none', trainer_params=None, model_params=None, optimizer='Adam', optimizer_params=None, lr_scheduler='ReduceLROnPlateau', lr_scheduler_params=None, train_dataloader_params=None, val_dataloader_params=None, checkpoint_params=None)` #

Create a configuration for training Noise2Noise.

If "Z" is present in axes, then patch_size must be a list of length 3, otherwise 2.

If "C" is present in axes, then you need to set n_channels_in to the number of channels. Likewise, if you set the number of channels, then "C" must be present in axes.

To set the number of output channels, use the n_channels_out parameter. If it is not specified, it will be assumed to be equal to n_channels_in.

By default, all channels are trained together. To train all channels independently, set independent_channels to True.

By setting augmentations to None, the default transformations (flip in X and Y, rotations by 90 degrees in the XY plane) are applied. Rather than the default transforms, a list of transforms can be passed to the augmentations parameter. To disable the transforms, simply pass an empty list.

Parameters:

Name	Type	Description	Default
`experiment_name`	`str`	Name of the experiment.	required
`data_type`	`Literal['array', 'tiff', 'czi', 'custom']`	Type of the data.	required
`axes`	`str`	Axes of the data (e.g. SYX).	required
`patch_size`	`List[int]`	Size of the patches along the spatial dimensions (e.g. [64, 64]).	required
`batch_size`	`int`	Batch size.	required
`num_epochs`	`int`	Number of epochs to train for. If provided, this will be added to trainer_params.	`100`
`num_steps`	`int`	Number of batches in 1 epoch. If provided, this will be added to trainer_params. Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant documentation for more details.	`None`
`augmentations`	`list of transforms`	List of transforms to apply, either both or one of XYFlipConfig and XYRandomRotate90Config. By default, it applies both XYFlip (on X and Y) and XYRandomRotate90 (in XY) to the images.	`None`
`independent_channels`	`bool`	Whether to train all channels independently, by default False.	`True`
`loss`	`Literal['mae', 'mse']`	Loss function to use, by default "mae".	`'mae'`
`n_channels_in`	`int or None`	Number of channels in.	`None`
`n_channels_out`	`int or None`	Number of channels out.	`None`
`logger`	`Literal['wandb', 'tensorboard', 'none']`	Logger to use, by default "none".	`'none'`
`trainer_params`	`dict`	Parameters for the trainer class, see PyTorch Lightning documentation.	`None`
`model_params`	`dict`	UNetModel parameters.	`None`
`optimizer`	`Literal['Adam', 'Adamax', 'SGD']`	Optimizer to use.	`"Adam"`
`optimizer_params`	`dict`	Parameters for the optimizer, see PyTorch documentation for more details.	`None`
`lr_scheduler`	`Literal['ReduceLROnPlateau', 'StepLR']`	Learning rate scheduler to use.	`"ReduceLROnPlateau"`
`lr_scheduler_params`	`dict`	Parameters for the learning rate scheduler, see PyTorch documentation for more details.	`None`
`train_dataloader_params`	`dict`	Parameters for the training dataloader, see the PyTorch docs for `DataLoader`. If left as `None`, the dict `{"shuffle": True}` will be used, this is set in the `GeneralDataConfig`.	`None`
`val_dataloader_params`	`dict`	Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`. If left as `None`, the empty dict `{}` will be used, this is set in the `GeneralDataConfig`.	`None`
`checkpoint_params`	`dict`	Parameters for the checkpoint callback, see PyTorch Lightning documentation (`ModelCheckpoint`) for the list of available parameters.	`None`

Returns:

Type	Description
`Configuration`	Configuration for training Noise2Noise.

Examples:

Minimum example:

>>> config = create_n2n_configuration(
...     experiment_name="n2n_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100
... )

You can also limit the number of batches per epoch:

>>> config = create_n2n_configuration(
...     experiment_name="n2n_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_steps=100  # limit to 100 batches per epoch
... )

To disable transforms, simply set augmentations to an empty list:

>>> config = create_n2n_configuration(
...     experiment_name="n2n_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     augmentations=[]
... )

A list of transforms can be passed to the augmentations parameter:

>>> from careamics.config.transformations import XYFlipConfig
>>> config = create_n2n_configuration(
...     experiment_name="n2n_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     augmentations=[
...         # No rotation and only Y flipping
...         XYFlipConfig(flip_x = False, flip_y = True)
...     ]
... )

If you are training multiple channels they will be trained independently by default, you simply need to specify the number of channels input (and optionally, the number of channels output):

>>> config = create_n2n_configuration(
...     experiment_name="n2n_experiment",
...     data_type="array",
...     axes="YXC", # channels must be in the axes
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     n_channels_in=3, # number of input channels
...     n_channels_out=1 # if applicable
... )

If instead you want to train multiple channels together, you need to turn off the independent_channels parameter:

>>> config = create_n2n_configuration(
...     experiment_name="n2n_experiment",
...     data_type="array",
...     axes="YXC", # channels must be in the axes
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     independent_channels=False,
...     n_channels_in=3,
...     n_channels_out=1 # if applicable
... )

If you would like to train on CZI files, use "czi" as data_type and "SCYX" as axes for 2-D or "SCZYX" for 3-D denoising. Note that "SCYX" can also be used for 3-D data but spatial context along the Z dimension will then not be taken into account.

>>> config_2d = create_n2n_configuration(
...     experiment_name="n2n_experiment",
...     data_type="czi",
...     axes="SCYX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     n_channels_in=1,
... )
>>> config_3d = create_n2n_configuration(
...     experiment_name="n2n_experiment",
...     data_type="czi",
...     axes="SCZYX",
...     patch_size=[16, 64, 64],
...     batch_size=16,
...     num_epochs=100,
...     n_channels_in=1,
... )

Source code in src/careamics/config/configuration_factories.py

def create_n2n_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    num_epochs: int = 100,
    num_steps: int | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    independent_channels: bool = True,
    loss: Literal["mae", "mse"] = "mae",
    n_channels_in: int | None = None,
    n_channels_out: int | None = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    trainer_params: dict | None = None,
    model_params: dict | None = None,
    optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
    optimizer_params: dict[str, Any] | None = None,
    lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
    lr_scheduler_params: dict[str, Any] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
    checkpoint_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training Noise2Noise.

    If "Z" is present in `axes`, then `patch_size` must be a list of length 3, otherwise
    2.

    If "C" is present in `axes`, then you need to set `n_channels_in` to the number of
    channels. Likewise, if you set the number of channels, then "C" must be present in
    `axes`.

    To set the number of output channels, use the `n_channels_out` parameter. If it is
    not specified, it will be assumed to be equal to `n_channels_in`.

    By default, all channels are trained together. To train all channels independently,
    set `independent_channels` to True.

    By setting `augmentations` to `None`, the default transformations (flip in X and Y,
    rotations by 90 degrees in the XY plane) are applied. Rather than the default
    transforms, a list of transforms can be passed to the `augmentations` parameter. To
    disable the transforms, simply pass an empty list.

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "czi", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    augmentations : list of transforms, default=None
        List of transforms to apply, either both or one of XYFlipConfig and
        XYRandomRotate90Config. By default, it applies both XYFlip (on X and Y)
        and XYRandomRotate90 (in XY) to the images.
    independent_channels : bool, optional
        Whether to train all channels independently, by default False.
    loss : Literal["mae", "mse"], optional
        Loss function to use, by default "mae".
    n_channels_in : int or None, default=None
        Number of channels in.
    n_channels_out : int or None, default=None
        Number of channels out.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use, by default "none".
    trainer_params : dict, optional
        Parameters for the trainer class, see PyTorch Lightning documentation.
    model_params : dict, default=None
        UNetModel parameters.
    optimizer : Literal["Adam", "Adamax", "SGD"], default="Adam"
        Optimizer to use.
    optimizer_params : dict, default=None
        Parameters for the optimizer, see PyTorch documentation for more details.
    lr_scheduler : Literal["ReduceLROnPlateau", "StepLR"], default="ReduceLROnPlateau"
        Learning rate scheduler to use.
    lr_scheduler_params : dict, default=None
        Parameters for the learning rate scheduler, see PyTorch documentation for more
        details.
    train_dataloader_params : dict, optional
        Parameters for the training dataloader, see the PyTorch docs for `DataLoader`.
        If left as `None`, the dict `{"shuffle": True}` will be used, this is set in
        the `GeneralDataConfig`.
    val_dataloader_params : dict, optional
        Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`.
        If left as `None`, the empty dict `{}` will be used, this is set in the
        `GeneralDataConfig`.
    checkpoint_params : dict, default=None
        Parameters for the checkpoint callback, see PyTorch Lightning documentation
        (`ModelCheckpoint`) for the list of available parameters.

    Returns
    -------
    Configuration
        Configuration for training Noise2Noise.

    Examples
    --------
    Minimum example:
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100
    ... )

    You can also limit the number of batches per epoch:
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_steps=100  # limit to 100 batches per epoch
    ... )

    To disable transforms, simply set `augmentations` to an empty list:
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[]
    ... )

    A list of transforms can be passed to the `augmentations` parameter:
    >>> from careamics.config.transformations import XYFlipConfig
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[
    ...         # No rotation and only Y flipping
    ...         XYFlipConfig(flip_x = False, flip_y = True)
    ...     ]
    ... )

    If you are training multiple channels they will be trained independently by default,
    you simply need to specify the number of channels input (and optionally, the number
    of channels output):
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YXC", # channels must be in the axes
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels_in=3, # number of input channels
    ...     n_channels_out=1 # if applicable
    ... )

    If instead you want to train multiple channels together, you need to turn off the
    `independent_channels` parameter:
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YXC", # channels must be in the axes
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     independent_channels=False,
    ...     n_channels_in=3,
    ...     n_channels_out=1 # if applicable
    ... )

    If you would like to train on CZI files, use `"czi"` as `data_type` and `"SCYX"` as
    `axes` for 2-D or `"SCZYX"` for 3-D denoising. Note that `"SCYX"` can also be used
    for 3-D data but spatial context along the Z dimension will then not be taken into
    account.
    >>> config_2d = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="czi",
    ...     axes="SCYX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels_in=1,
    ... )
    >>> config_3d = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="czi",
    ...     axes="SCZYX",
    ...     patch_size=[16, 64, 64],
    ...     batch_size=16,
    ...     num_epochs=100,
    ...     n_channels_in=1,
    ... )
    """
    return Configuration(
        **_create_supervised_config_dict(
            algorithm="n2n",
            experiment_name=experiment_name,
            data_type=data_type,
            axes=axes,
            patch_size=patch_size,
            batch_size=batch_size,
            trainer_params=trainer_params,
            augmentations=augmentations,
            independent_channels=independent_channels,
            loss=loss,
            n_channels_in=n_channels_in,
            n_channels_out=n_channels_out,
            logger=logger,
            model_params=model_params,
            optimizer=optimizer,
            optimizer_params=optimizer_params,
            lr_scheduler=lr_scheduler,
            lr_scheduler_params=lr_scheduler_params,
            train_dataloader_params=train_dataloader_params,
            val_dataloader_params=val_dataloader_params,
            checkpoint_params=checkpoint_params,
            num_epochs=num_epochs,
            num_steps=num_steps,
        )
    )

create_n2v_configuration(experiment_name, data_type, axes, patch_size, batch_size, num_epochs=100, num_steps=None, augmentations=None, independent_channels=True, use_n2v2=False, n_channels=None, roi_size=11, masked_pixel_percentage=0.2, struct_n2v_axis='none', struct_n2v_span=5, trainer_params=None, logger='none', model_params=None, optimizer='Adam', optimizer_params=None, lr_scheduler='ReduceLROnPlateau', lr_scheduler_params=None, train_dataloader_params=None, val_dataloader_params=None, checkpoint_params=None) #

Create a configuration for training Noise2Void.

N2V uses a UNet model to denoise images in a self-supervised manner. To use its variants structN2V and N2V2, set the struct_n2v_axis and struct_n2v_span (structN2V) parameters, or set use_n2v2 to True (N2V2).

N2V2 modifies the UNet architecture by adding blur pool layers and removes the skip connections, thus removing checkboard artefacts. StructN2V is used when vertical or horizontal correlations are present in the noise; it applies an additional mask to the manipulated pixel neighbors.

If "Z" is present in axes, then patch_size must be a list of length 3, otherwise 2.

If "C" is present in axes, then you need to set n_channels to the number of channels.

By default, all channels are trained independently. To train all channels together, set independent_channels to False.

By default, the transformations applied are a random flip along X or Y, and a random 90 degrees rotation in the XY plane. Normalization is always applied, as well as the N2V manipulation.

By setting augmentations to None, the default transformations (flip in X and Y, rotations by 90 degrees in the XY plane) are applied. Rather than the default transforms, a list of transforms can be passed to the augmentations parameter. To disable the transforms, simply pass an empty list.

The roi_size parameter specifies the size of the area around each pixel that will be manipulated by N2V. The masked_pixel_percentage parameter specifies how many pixels per patch will be manipulated.

The parameters of the UNet can be specified in the model_params (passed as a parameter-value dictionary). Note that use_n2v2 and 'n_channels' override the corresponding parameters passed in model_params.

If you pass "horizontal" or "vertical" to struct_n2v_axis, then structN2V mask will be applied to each manipulated pixel.

Parameters:

Name	Type	Description	Default
`experiment_name`	`str`	Name of the experiment.	required
`data_type`	`Literal['array', 'tiff', 'czi', 'custom']`	Type of the data.	required
`axes`	`str`	Axes of the data (e.g. SYX).	required
`patch_size`	`List[int]`	Size of the patches along the spatial dimensions (e.g. [64, 64]).	required
`batch_size`	`int`	Batch size.	required
`num_epochs`	`int`	Number of epochs to train for. If provided, this will be added to trainer_params.	`100`
`num_steps`	`int`	Number of batches in 1 epoch. If provided, this will be added to trainer_params. Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant documentation for more details.	`None`
`augmentations`	`list of transforms`	List of transforms to apply, either both or one of XYFlipConfig and XYRandomRotate90Config. By default, it applies both XYFlip (on X and Y) and XYRandomRotate90 (in XY) to the images.	`None`
`independent_channels`	`bool`	Whether to train all channels together, by default True.	`True`
`use_n2v2`	`bool`	Whether to use N2V2, by default False.	`False`
`n_channels`	`int or None`	Number of channels (in and out).	`None`
`roi_size`	`int`	N2V pixel manipulation area, by default 11.	`11`
`masked_pixel_percentage`	`float`	Percentage of pixels masked in each patch, by default 0.2.	`0.2`
`struct_n2v_axis`	`Literal['horizontal', 'vertical', 'none']`	Axis along which to apply structN2V mask, by default "none".	`'none'`
`struct_n2v_span`	`int`	Span of the structN2V mask, by default 5.	`5`
`trainer_params`	`dict`	Parameters for the trainer, see the relevant documentation.	`None`
`logger`	`Literal['wandb', 'tensorboard', 'none']`	Logger to use, by default "none".	`'none'`
`model_params`	`dict`	UNetModel parameters.	`None`
`optimizer`	`Literal['Adam', 'Adamax', 'SGD']`	Optimizer to use.	`"Adam"`
`optimizer_params`	`dict`	Parameters for the optimizer, see PyTorch documentation for more details.	`None`
`lr_scheduler`	`Literal['ReduceLROnPlateau', 'StepLR']`	Learning rate scheduler to use.	`"ReduceLROnPlateau"`
`lr_scheduler_params`	`dict`	Parameters for the learning rate scheduler, see PyTorch documentation for more details.	`None`
`train_dataloader_params`	`dict`	Parameters for the training dataloader, see the PyTorch docs for `DataLoader`. If left as `None`, the dict `{"shuffle": True}` will be used, this is set in the `GeneralDataConfig`.	`None`
`val_dataloader_params`	`dict`	Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`. If left as `None`, the empty dict `{}` will be used, this is set in the `GeneralDataConfig`.	`None`
`checkpoint_params`	`dict`	Parameters for the checkpoint callback, see PyTorch Lightning documentation (`ModelCheckpoint`) for the list of available parameters.	`None`

Returns:

Type	Description
`Configuration`	Configuration for training N2V.

Examples:

Minimum example:

>>> config = create_n2v_configuration(
...     experiment_name="n2v_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100
... )

You can also limit the number of batches per epoch:

>>> config = create_n2v_configuration(
...     experiment_name="n2v_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_steps=100  # limit to 100 batches per epoch
... )

To disable transforms, simply set augmentations to an empty list:

>>> config = create_n2v_configuration(
...     experiment_name="n2v_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     augmentations=[]
... )

A list of transforms can be passed to the augmentations parameter:

>>> from careamics.config.transformations import XYFlipConfig
>>> config = create_n2v_configuration(
...     experiment_name="n2v_experiment",
...     data_type="array",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     augmentations=[
...         # No rotation and only Y flipping
...         XYFlipConfig(flip_x = False, flip_y = True)
...     ]
... )

To use N2V2, simply pass the use_n2v2 parameter:

>>> config = create_n2v_configuration(
...     experiment_name="n2v2_experiment",
...     data_type="tiff",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     use_n2v2=True
... )

For structN2V, there are two parameters to set, struct_n2v_axis and struct_n2v_span:

>>> config = create_n2v_configuration(
...     experiment_name="structn2v_experiment",
...     data_type="tiff",
...     axes="YX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     struct_n2v_axis="horizontal",
...     struct_n2v_span=7
... )

If you are training multiple channels they will be trained independently by default, you simply need to specify the number of channels:

>>> config = create_n2v_configuration(
...     experiment_name="n2v_experiment",
...     data_type="array",
...     axes="YXC",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     n_channels=3
... )

If instead you want to train multiple channels together, you need to turn off the independent_channels parameter:

>>> config = create_n2v_configuration(
...     experiment_name="n2v_experiment",
...     data_type="array",
...     axes="YXC",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     independent_channels=False,
...     n_channels=3
... )

If you would like to train on CZI files, use "czi" as data_type and "SCYX" as axes for 2-D or "SCZYX" for 3-D denoising. Note that "SCYX" can also be used for 3-D data but spatial context along the Z dimension will then not be taken into account.

>>> config_2d = create_n2v_configuration(
...     experiment_name="n2v_experiment",
...     data_type="czi",
...     axes="SCYX",
...     patch_size=[64, 64],
...     batch_size=32,
...     num_epochs=100,
...     n_channels=1,
... )
>>> config_3d = create_n2v_configuration(
...     experiment_name="n2v_experiment",
...     data_type="czi",
...     axes="SCZYX",
...     patch_size=[16, 64, 64],
...     batch_size=16,
...     num_epochs=100,
...     n_channels=1,
... )

Source code in src/careamics/config/configuration_factories.py

def create_n2v_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    num_epochs: int = 100,
    num_steps: int | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    independent_channels: bool = True,
    use_n2v2: bool = False,
    n_channels: int | None = None,
    roi_size: int = 11,
    masked_pixel_percentage: float = 0.2,
    struct_n2v_axis: Literal["horizontal", "vertical", "none"] = "none",
    struct_n2v_span: int = 5,
    trainer_params: dict | None = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    model_params: dict | None = None,
    optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
    optimizer_params: dict[str, Any] | None = None,
    lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
    lr_scheduler_params: dict[str, Any] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
    checkpoint_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training Noise2Void.

    N2V uses a UNet model to denoise images in a self-supervised manner. To use its
    variants structN2V and N2V2, set the `struct_n2v_axis` and `struct_n2v_span`
    (structN2V) parameters, or set `use_n2v2` to True (N2V2).

    N2V2 modifies the UNet architecture by adding blur pool layers and removes the skip
    connections, thus removing checkboard artefacts. StructN2V is used when vertical
    or horizontal correlations are present in the noise; it applies an additional mask
    to the manipulated pixel neighbors.

    If "Z" is present in `axes`, then `patch_size` must be a list of length 3, otherwise
    2.

    If "C" is present in `axes`, then you need to set `n_channels` to the number of
    channels.

    By default, all channels are trained independently. To train all channels together,
    set `independent_channels` to False.

    By default, the transformations applied are a random flip along X or Y, and a random
    90 degrees rotation in the XY plane. Normalization is always applied, as well as the
    N2V manipulation.

    By setting `augmentations` to `None`, the default transformations (flip in X and Y,
    rotations by 90 degrees in the XY plane) are applied. Rather than the default
    transforms, a list of transforms can be passed to the `augmentations` parameter. To
    disable the transforms, simply pass an empty list.

    The `roi_size` parameter specifies the size of the area around each pixel that will
    be manipulated by N2V. The `masked_pixel_percentage` parameter specifies how many
    pixels per patch will be manipulated.

    The parameters of the UNet can be specified in the `model_params` (passed as a
    parameter-value dictionary). Note that `use_n2v2` and 'n_channels' override the
    corresponding parameters passed in `model_params`.

    If you pass "horizontal" or "vertical" to `struct_n2v_axis`, then structN2V mask
    will be applied to each manipulated pixel.

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "czi", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    augmentations : list of transforms, default=None
        List of transforms to apply, either both or one of XYFlipConfig and
        XYRandomRotate90Config. By default, it applies both XYFlip (on X and Y)
        and XYRandomRotate90 (in XY) to the images.
    independent_channels : bool, optional
        Whether to train all channels together, by default True.
    use_n2v2 : bool, optional
        Whether to use N2V2, by default False.
    n_channels : int or None, default=None
        Number of channels (in and out).
    roi_size : int, optional
        N2V pixel manipulation area, by default 11.
    masked_pixel_percentage : float, optional
        Percentage of pixels masked in each patch, by default 0.2.
    struct_n2v_axis : Literal["horizontal", "vertical", "none"], optional
        Axis along which to apply structN2V mask, by default "none".
    struct_n2v_span : int, optional
        Span of the structN2V mask, by default 5.
    trainer_params : dict, optional
        Parameters for the trainer, see the relevant documentation.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use, by default "none".
    model_params : dict, default=None
        UNetModel parameters.
    optimizer : Literal["Adam", "Adamax", "SGD"], default="Adam"
        Optimizer to use.
    optimizer_params : dict, default=None
        Parameters for the optimizer, see PyTorch documentation for more details.
    lr_scheduler : Literal["ReduceLROnPlateau", "StepLR"], default="ReduceLROnPlateau"
        Learning rate scheduler to use.
    lr_scheduler_params : dict, default=None
        Parameters for the learning rate scheduler, see PyTorch documentation for more
        details.
    train_dataloader_params : dict, optional
        Parameters for the training dataloader, see the PyTorch docs for `DataLoader`.
        If left as `None`, the dict `{"shuffle": True}` will be used, this is set in
        the `GeneralDataConfig`.
    val_dataloader_params : dict, optional
        Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`.
        If left as `None`, the empty dict `{}` will be used, this is set in the
        `GeneralDataConfig`.
    checkpoint_params : dict, default=None
        Parameters for the checkpoint callback, see PyTorch Lightning documentation
        (`ModelCheckpoint`) for the list of available parameters.

    Returns
    -------
    Configuration
        Configuration for training N2V.

    Examples
    --------
    Minimum example:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100
    ... )

    You can also limit the number of batches per epoch:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_steps=100  # limit to 100 batches per epoch
    ... )

    To disable transforms, simply set `augmentations` to an empty list:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[]
    ... )

    A list of transforms can be passed to the `augmentations` parameter:
    >>> from careamics.config.transformations import XYFlipConfig
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[
    ...         # No rotation and only Y flipping
    ...         XYFlipConfig(flip_x = False, flip_y = True)
    ...     ]
    ... )

    To use N2V2, simply pass the `use_n2v2` parameter:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v2_experiment",
    ...     data_type="tiff",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     use_n2v2=True
    ... )

    For structN2V, there are two parameters to set, `struct_n2v_axis` and
    `struct_n2v_span`:
    >>> config = create_n2v_configuration(
    ...     experiment_name="structn2v_experiment",
    ...     data_type="tiff",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     struct_n2v_axis="horizontal",
    ...     struct_n2v_span=7
    ... )

    If you are training multiple channels they will be trained independently by default,
    you simply need to specify the number of channels:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YXC",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels=3
    ... )

    If instead you want to train multiple channels together, you need to turn off the
    `independent_channels` parameter:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YXC",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     independent_channels=False,
    ...     n_channels=3
    ... )

    If you would like to train on CZI files, use `"czi"` as `data_type` and `"SCYX"` as
    `axes` for 2-D or `"SCZYX"` for 3-D denoising. Note that `"SCYX"` can also be used
    for 3-D data but spatial context along the Z dimension will then not be taken into
    account.
    >>> config_2d = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="czi",
    ...     axes="SCYX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels=1,
    ... )
    >>> config_3d = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="czi",
    ...     axes="SCZYX",
    ...     patch_size=[16, 64, 64],
    ...     batch_size=16,
    ...     num_epochs=100,
    ...     n_channels=1,
    ... )
    """
    # if there are channels, we need to specify their number
    if "C" in axes and n_channels is None:
        raise ValueError("Number of channels must be specified when using channels.")
    elif "C" not in axes and (n_channels is not None and n_channels > 1):
        raise ValueError(
            f"C is not present in the axes, but number of channels is specified "
            f"(got {n_channels} channel)."
        )

    if n_channels is None:
        n_channels = 1

    # augmentations
    spatial_transforms = _list_spatial_augmentations(augmentations)

    # create the N2VManipulate transform using the supplied parameters
    n2v_transform = N2VManipulateConfig(
        name=SupportedTransform.N2V_MANIPULATE.value,
        strategy=(
            SupportedPixelManipulation.MEDIAN.value
            if use_n2v2
            else SupportedPixelManipulation.UNIFORM.value
        ),
        roi_size=roi_size,
        masked_pixel_percentage=masked_pixel_percentage,
        struct_mask_axis=struct_n2v_axis,
        struct_mask_span=struct_n2v_span,
    )

    # algorithm
    algorithm_params = _create_algorithm_configuration(
        axes=axes,
        algorithm="n2v",
        loss="n2v",
        independent_channels=independent_channels,
        n_channels_in=n_channels,
        n_channels_out=n_channels,
        use_n2v2=use_n2v2,
        model_params=model_params,
        optimizer=optimizer,
        optimizer_params=optimizer_params,
        lr_scheduler=lr_scheduler,
        lr_scheduler_params=lr_scheduler_params,
    )
    algorithm_params["n2v_config"] = n2v_transform

    # data
    data_params = _create_data_configuration(
        data_type=data_type,
        axes=axes,
        patch_size=patch_size,
        batch_size=batch_size,
        augmentations=spatial_transforms,
        train_dataloader_params=train_dataloader_params,
        val_dataloader_params=val_dataloader_params,
    )

    # training
    final_trainer_params = update_trainer_params(
        trainer_params=trainer_params,
        num_epochs=num_epochs,
        num_steps=num_steps,
    )
    training_params = _create_training_configuration(
        trainer_params=final_trainer_params,
        logger=logger,
        checkpoint_params=checkpoint_params,
    )

    return Configuration(
        experiment_name=experiment_name,
        algorithm_config=algorithm_params,
        data_config=data_params,
        training_config=training_params,
    )

`create_ng_data_configuration(data_type, axes, patch_size, batch_size, augmentations=None, channels=None, in_memory=None, patch_overlaps=None, train_dataloader_params=None, val_dataloader_params=None, pred_dataloader_params=None, seed=None)` #

Create a training NGDatasetConfig.

Parameters:

Name	Type	Description	Default
`data_type`	`(array, tiff, zarr, czi, custom)`	Type of the data.	`"array"`
`axes`	`str`	Axes of the data.	required
`patch_size`	`list of int`	Size of the patches along the spatial dimensions.	required
`batch_size`	`int`	Batch size.	required
`augmentations`	`list of transforms`	List of transforms to apply.	`None`
`channels`	`Sequence of int`	List of channels to use. If `None`, all channels are used.	`None`
`in_memory`	`bool`	Whether to load all data into memory. This is only supported for 'array', 'tiff' and 'custom' data types. If `None`, defaults to `True` for 'array', 'tiff' and `custom`, and `False` for 'zarr' and 'czi' data types. Must be `True` for `array`.	`None`
`augmentations`	`list of transforms or None`	List of transforms to apply. If `None`, default augmentations are applied (flip in X and Y, rotations by 90 degrees in the XY plane).	`None`
`patch_overlaps`	`Sequence of int`	Overlaps between patches in each spatial dimension, only used with "sequential" patching. If `None`, no overlap is applied. The overlap must be smaller than the patch size in each spatial dimension, and the number of dimensions be either 2 or 3.	`None`
`train_dataloader_params`	`dict`	Parameters for the training dataloader, see PyTorch notes, by default None.	`None`
`val_dataloader_params`	`dict`	Parameters for the validation dataloader, see PyTorch notes, by default None.	`None`
`pred_dataloader_params`	`dict`	Parameters for the test dataloader, see PyTorch notes, by default None.	`None`
`seed`	`int`	Random seed for reproducibility. If `None`, no seed is set.	`None`

Returns:

Type	Description
`NGDataConfig`	Next-Generation Data model with the specified parameters.

Source code in src/careamics/config/configuration_factories.py

def create_ng_data_configuration(
    data_type: Literal["array", "tiff", "zarr", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    augmentations: list[SPATIAL_TRANSFORMS_UNION] | None = None,
    channels: Sequence[int] | None = None,
    in_memory: bool | None = None,
    patch_overlaps: Sequence[int] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
    pred_dataloader_params: dict[str, Any] | None = None,
    seed: int | None = None,
) -> NGDataConfig:
    """
    Create a training NGDatasetConfig.

    Parameters
    ----------
    data_type : {"array", "tiff", "zarr", "czi", "custom"}
        Type of the data.
    axes : str
        Axes of the data.
    patch_size : list of int
        Size of the patches along the spatial dimensions.
    batch_size : int
        Batch size.
    augmentations : list of transforms
        List of transforms to apply.
    channels : Sequence of int, default=None
        List of channels to use. If `None`, all channels are used.
    in_memory : bool, default=None
        Whether to load all data into memory. This is only supported for 'array',
        'tiff' and 'custom' data types. If `None`, defaults to `True` for 'array',
        'tiff' and `custom`, and `False` for 'zarr' and 'czi' data types. Must be `True`
        for `array`.
    augmentations : list of transforms or None, default=None
        List of transforms to apply. If `None`, default augmentations are applied
        (flip in X and Y, rotations by 90 degrees in the XY plane).
    patch_overlaps : Sequence of int, default=None
        Overlaps between patches in each spatial dimension, only used with "sequential"
        patching. If `None`, no overlap is applied. The overlap must be smaller than
        the patch size in each spatial dimension, and the number of dimensions be either
        2 or 3.
    train_dataloader_params : dict
        Parameters for the training dataloader, see PyTorch notes, by default None.
    val_dataloader_params : dict
        Parameters for the validation dataloader, see PyTorch notes, by default None.
    pred_dataloader_params : dict
        Parameters for the test dataloader, see PyTorch notes, by default None.
    seed : int, default=None
        Random seed for reproducibility. If `None`, no seed is set.

    Returns
    -------
    NGDataConfig
        Next-Generation Data model with the specified parameters.
    """
    if augmentations is None:
        augmentations = _list_spatial_augmentations()

    # data model
    data: dict[str, Any] = {
        "mode": "training",
        "data_type": data_type,
        "axes": axes,
        "batch_size": batch_size,
        "channels": channels,
        "transforms": augmentations,
        "seed": seed,
    }

    if in_memory is not None:
        data["in_memory"] = in_memory

    # don't override defaults set in DataConfig class
    if train_dataloader_params is not None:
        # the presence of `shuffle` key in the dataloader parameters is enforced
        # by the NGDataConfig class
        if "shuffle" not in train_dataloader_params:
            train_dataloader_params["shuffle"] = True

        data["train_dataloader_params"] = train_dataloader_params

    if val_dataloader_params is not None:
        data["val_dataloader_params"] = val_dataloader_params

    if pred_dataloader_params is not None:
        data["pred_dataloader_params"] = pred_dataloader_params

    # add training patching
    data["patching"] = {
        "name": "random",
        "patch_size": patch_size,
        "overlaps": patch_overlaps,
    }

    return NGDataConfig(**data)

create_pn2v_configuration(experiment_name, data_type, axes, patch_size, batch_size, nm_path, num_epochs=100, num_steps=None, augmentations=None, independent_channels=True, use_n2v2=False, num_in_channels=1, num_out_channels=100, roi_size=11, masked_pixel_percentage=0.2, struct_n2v_axis='none', struct_n2v_span=5, trainer_params=None, logger='none', model_params=None, optimizer='Adam', optimizer_params=None, lr_scheduler='ReduceLROnPlateau', lr_scheduler_params=None, train_dataloader_params=None, val_dataloader_params=None, checkpoint_params=None) #

Create a configuration for training Probabilistic Noise2Void (PN2V).

PN2V extends N2V by incorporating a probabilistic noise model to estimate the posterior distibution of each pixel more precisely.

If "Z" is present in axes, then path_size must be a list of length 3, otherwise 2.

If "C" is present in axes, then you need to set num_in_channels to the number of channels.

By default, all channels are trained independently. To train all channels together, set independent_channels to False. When training independently, each input channel will have num_out_channels outputs (default 400). When training together, all input channels will share num_out_channels outputs.

By default, the transformations applied are a random flip along X or Y, and a random 90 degrees rotation in the XY plane. Normalization is always applied, as well as the N2V manipulation.

By setting augmentations to None, the default transformations (flip in X and Y, rotations by 90 degrees in the XY plane) are applied. Rather than the default transforms, a list of transforms can be passed to the augmentations parameter. To disable the transforms, simply pass an empty list.

The roi_size parameter specifies the size of the area around each pixel that will be manipulated by N2V. The masked_pixel_percentage parameter specifies how many pixels per patch will be manipulated.

The parameters of the UNet can be specified in the model_params (passed as a parameter-value dictionary). Note that use_n2v2, num_in_channels, and num_out_channels override the corresponding parameters passed in model_params.

If you pass "horizontal" or "vertical" to struct_n2v_axis, then structN2V mask will be applied to each manipulated pixel.

Parameters:

Name	Type	Description	Default
`experiment_name`	`str`	Name of the experiment.	required
`data_type`	`Literal['array', 'tiff', 'czi', 'custom']`	Type of the data.	required
`axes`	`str`	Axes of the data (e.g. SYX).	required
`patch_size`	`List[int]`	Size of the patches along the spatial dimensions (e.g. [64, 64]).	required
`batch_size`	`int`	Batch size.	required
`nm_path`	`str`	Path to the noise model file.	required
`num_epochs`	`int`	Number of epochs to train for. If provided, this will be added to trainer_params.	`100`
`num_steps`	`int`	Number of batches in 1 epoch. If provided, this will be added to trainer_params. Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant documentation for more details.	`None`
`augmentations`	`list of transforms`	List of transforms to apply, either both or one of XYFlipModel and XYRandomRotate90Model. By default, it applies both XYFlip (on X and Y) and XYRandomRotate90 (in XY) to the images.	`None`
`independent_channels`	`bool`	Whether to train all channels independently, by default True. If True, each input channel will correspond to num_out_channels output channels (e.g., 3 input channels with num_out_channels=400 results in 1200 total output channels).	`True`
`use_n2v2`	`bool`	Whether to use N2V2, by default False.	`False`
`num_in_channels`	`int`	Number of input channels.	`1`
`num_out_channels`	`int`	Number of output channels per input channel when independent_channels is True, or total number of output channels when independent_channels is False.	`400`
`roi_size`	`int`	N2V pixel manipulation area, by default 11.	`11`
`masked_pixel_percentage`	`float`	Percentage of pixels masked in each patch, by default 0.2.	`0.2`
`struct_n2v_axis`	`Literal['horizontal', 'vertical', 'none']`	Axis along which to apply structN2V mask, by default "none".	`'none'`
`struct_n2v_span`	`int`	Span of the structN2V mask, by default 5.	`5`
`trainer_params`	`dict`	Parameters for the trainer, see the relevant documentation.	`None`
`logger`	`Literal['wandb', 'tensorboard', 'none']`	Logger to use, by default "none".	`'none'`
`model_params`	`dict`	UNetModel parameters.	`None`
`optimizer`	`Literal['Adam', 'Adamax', 'SGD']`	Optimizer to use.	`"Adam"`
`optimizer_params`	`dict`	Parameters for the optimizer, see PyTorch documentation for more details.	`None`
`lr_scheduler`	`Literal['ReduceLROnPlateau', 'StepLR']`	Learning rate scheduler to use.	`"ReduceLROnPlateau"`
`lr_scheduler_params`	`dict`	Parameters for the learning rate scheduler, see PyTorch documentation for more details.	`None`
`train_dataloader_params`	`dict`	Parameters for the training dataloader, see the PyTorch docs for `DataLoader`. If left as `None`, the dict `{"shuffle": True}` will be used, this is set in the `GeneralDataConfig`.	`None`
`val_dataloader_params`	`dict`	Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`. If left as `None`, the empty dict `{}` will be used, this is set in the `GeneralDataConfig`.	`None`
`checkpoint_params`	`dict`	Parameters for the checkpoint callback, see PyTorch Lightning documentation (`ModelCheckpoint`) for the list of available parameters.	`None`

Returns:

Type	Description
`Configuration`	Configuration for training PN2V.

Examples:

Minimum example:

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100#

... )#

You can also limit the number of batches per epoch:#

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_steps=100 # limit to 100 batches per epoch#

... )#

To disable transforms, simply set `augmentations` to an empty list:#

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... augmentations=[]#

... )#

A list of transforms can be passed to the `augmentations` parameter:#

>>> from careamics.config.transformations import XYFlipModel#

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... augmentations=[#

... # No rotation and only Y flipping#

... XYFlipModel(flip_x = False, flip_y = True)#

... ]#

... )#

To use N2V2, simply pass the `use_n2v2` parameter:#

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v2_experiment",#

... data_type="tiff",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... use_n2v2=True#

... )#

For structN2V, there are two parameters to set, `struct_n2v_axis` and#

`struct_n2v_span`:#

>>> config = create_pn2v_configuration(#

... experiment_name="structpn2v_experiment",#

... data_type="tiff",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... struct_n2v_axis="horizontal",#

... struct_n2v_span=7#

... )#

If you are training multiple channels they will be trained independently by#

default, you simply need to specify the number of input channels. Each input#

channel will correspond to num_out_channels outputs (1200 total for 3#

channels with default num_out_channels=400):#

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="array",#

... axes="YXC",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... num_in_channels=3#

... )#

If instead you want to train multiple channels together, you need to turn#

off the `independent_channels` parameter (resulting in 400 total output#

channels regardless of the number of input channels):#

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="array",#

... axes="YXC",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... independent_channels=False,#

... num_in_channels=3#

... )#

>>> config_2d = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="czi",#

... axes="SCYX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... num_in_channels=1,#

... )#

>>> config_3d = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="czi",#

... axes="SCZYX",#

... patch_size=[16, 64, 64],#

... batch_size=16,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... num_in_channels=1,#

... )#

Source code in src/careamics/config/configuration_factories.py

def create_pn2v_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    nm_path: str,
    num_epochs: int = 100,
    num_steps: int | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    independent_channels: bool = True,
    use_n2v2: bool = False,
    num_in_channels: int = 1,
    num_out_channels: int = 100,
    roi_size: int = 11,
    masked_pixel_percentage: float = 0.2,
    struct_n2v_axis: Literal["horizontal", "vertical", "none"] = "none",
    struct_n2v_span: int = 5,
    trainer_params: dict | None = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    model_params: dict | None = None,
    optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
    optimizer_params: dict[str, Any] | None = None,
    lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
    lr_scheduler_params: dict[str, Any] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
    checkpoint_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training Probabilistic Noise2Void (PN2V).

    PN2V extends N2V by incorporating a probabilistic noise model to estimate the
    posterior distibution of each pixel more precisely.

    If "Z" is present in `axes`, then `path_size` must be a list of length 3, otherwise
    2.

    If "C" is present in `axes`, then you need to set `num_in_channels` to the number of
    channels.

    By default, all channels are trained independently. To train all channels together,
    set `independent_channels` to False. When training independently, each input channel
    will have `num_out_channels` outputs (default 400). When training together, all
    input channels will share `num_out_channels` outputs.

    By default, the transformations applied are a random flip along X or Y, and a random
    90 degrees rotation in the XY plane. Normalization is always applied, as well as the
    N2V manipulation.

    By setting `augmentations` to `None`, the default transformations (flip in X and Y,
    rotations by 90 degrees in the XY plane) are applied. Rather than the default
    transforms, a list of transforms can be passed to the `augmentations` parameter. To
    disable the transforms, simply pass an empty list.

    The `roi_size` parameter specifies the size of the area around each pixel that will
    be manipulated by N2V. The `masked_pixel_percentage` parameter specifies how many
    pixels per patch will be manipulated.

    The parameters of the UNet can be specified in the `model_params` (passed as a
    parameter-value dictionary). Note that `use_n2v2`, `num_in_channels`, and
    `num_out_channels` override the corresponding parameters passed in `model_params`.

    If you pass "horizontal" or "vertical" to `struct_n2v_axis`, then structN2V mask
    will be applied to each manipulated pixel.

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "czi", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    nm_path : str
        Path to the noise model file.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    augmentations : list of transforms, default=None
        List of transforms to apply, either both or one of XYFlipModel and
        XYRandomRotate90Model. By default, it applies both XYFlip (on X and Y)
        and XYRandomRotate90 (in XY) to the images.
    independent_channels : bool, optional
        Whether to train all channels independently, by default True. If True, each
        input channel will correspond to num_out_channels output channels (e.g., 3
        input channels with num_out_channels=400 results in 1200 total output
        channels).
    use_n2v2 : bool, optional
        Whether to use N2V2, by default False.
    num_in_channels : int, default=1
        Number of input channels.
    num_out_channels : int, default=400
        Number of output channels per input channel when independent_channels is True,
        or total number of output channels when independent_channels is False.
    roi_size : int, optional
        N2V pixel manipulation area, by default 11.
    masked_pixel_percentage : float, optional
        Percentage of pixels masked in each patch, by default 0.2.
    struct_n2v_axis : Literal["horizontal", "vertical", "none"], optional
        Axis along which to apply structN2V mask, by default "none".
    struct_n2v_span : int, optional
        Span of the structN2V mask, by default 5.
    trainer_params : dict, optional
        Parameters for the trainer, see the relevant documentation.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use, by default "none".
    model_params : dict, default=None
        UNetModel parameters.
    optimizer : Literal["Adam", "Adamax", "SGD"], default="Adam"
        Optimizer to use.
    optimizer_params : dict, default=None
        Parameters for the optimizer, see PyTorch documentation for more details.
    lr_scheduler : Literal["ReduceLROnPlateau", "StepLR"], default="ReduceLROnPlateau"
        Learning rate scheduler to use.
    lr_scheduler_params : dict, default=None
        Parameters for the learning rate scheduler, see PyTorch documentation for more
        details.
    train_dataloader_params : dict, optional
        Parameters for the training dataloader, see the PyTorch docs for `DataLoader`.
        If left as `None`, the dict `{"shuffle": True}` will be used, this is set in
        the `GeneralDataConfig`.
    val_dataloader_params : dict, optional
        Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`.
        If left as `None`, the empty dict `{}` will be used, this is set in the
        `GeneralDataConfig`.
    checkpoint_params : dict, default=None
        Parameters for the checkpoint callback, see PyTorch Lightning documentation
        (`ModelCheckpoint`) for the list of available parameters.

    Returns
    -------
    Configuration
        Configuration for training PN2V.

    Examples
    --------
    Minimum example:
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100
    # ... )

    # You can also limit the number of batches per epoch:
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_steps=100  # limit to 100 batches per epoch
    # ... )

    # To disable transforms, simply set `augmentations` to an empty list:
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     augmentations=[]
    # ... )

    # A list of transforms can be passed to the `augmentations` parameter:
    # >>> from careamics.config.transformations import XYFlipModel
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     augmentations=[
    # ...         # No rotation and only Y flipping
    # ...         XYFlipModel(flip_x = False, flip_y = True)
    # ...     ]
    # ... )

    # To use N2V2, simply pass the `use_n2v2` parameter:
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v2_experiment",
    # ...     data_type="tiff",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     use_n2v2=True
    # ... )

    # For structN2V, there are two parameters to set, `struct_n2v_axis` and
    # `struct_n2v_span`:
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="structpn2v_experiment",
    # ...     data_type="tiff",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     struct_n2v_axis="horizontal",
    # ...     struct_n2v_span=7
    # ... )

    # If you are training multiple channels they will be trained independently by
    # default, you simply need to specify the number of input channels. Each input
    # channel will correspond to num_out_channels outputs (1200 total for 3
    # channels with default num_out_channels=400):
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YXC",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     num_in_channels=3
    # ... )

    # If instead you want to train multiple channels together, you need to turn
    # off the `independent_channels` parameter (resulting in 400 total output
    # channels regardless of the number of input channels):
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YXC",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     independent_channels=False,
    # ...     num_in_channels=3
    # ... )

    # >>> config_2d = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="czi",
    # ...     axes="SCYX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     num_in_channels=1,
    # ... )
    # >>> config_3d = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="czi",
    # ...     axes="SCZYX",
    # ...     patch_size=[16, 64, 64],
    # ...     batch_size=16,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     num_in_channels=1,
    # ... )
    """
    # Validate channel configuration
    if "C" in axes and num_in_channels < 1:
        raise ValueError("num_in_channels must be at least 1 when using channels.")
    elif "C" not in axes and num_in_channels > 1:
        raise ValueError(
            f"C is not present in the axes, but num_in_channels is specified "
            f"(got {num_in_channels} channels)."
        )

    # Calculate total output channels based on independent_channels setting
    if independent_channels:
        total_out_channels = num_in_channels * num_out_channels
    else:
        total_out_channels = num_out_channels

    # augmentations
    spatial_transforms = _list_spatial_augmentations(augmentations)

    # create the N2VManipulate transform using the supplied parameters
    n2v_transform = N2VManipulateConfig(
        name=SupportedTransform.N2V_MANIPULATE.value,
        strategy=(
            SupportedPixelManipulation.MEDIAN.value
            if use_n2v2
            else SupportedPixelManipulation.UNIFORM.value
        ),
        roi_size=roi_size,
        masked_pixel_percentage=masked_pixel_percentage,
        struct_mask_axis=struct_n2v_axis,
        struct_mask_span=struct_n2v_span,
    )

    # Create noise model configuration
    noise_model_config = GaussianMixtureNMConfig(path=nm_path)

    # algorithm
    algorithm_params = _create_algorithm_configuration(
        axes=axes,
        algorithm="pn2v",
        loss="pn2v",
        independent_channels=independent_channels,
        n_channels_in=num_in_channels,
        n_channels_out=total_out_channels,
        use_n2v2=use_n2v2,
        model_params=model_params,
        optimizer=optimizer,
        optimizer_params=optimizer_params,
        lr_scheduler=lr_scheduler,
        lr_scheduler_params=lr_scheduler_params,
    )
    algorithm_params["n2v_config"] = n2v_transform
    algorithm_params["noise_model"] = noise_model_config

    # Convert to PN2VAlgorithm instance
    algorithm_config = PN2VAlgorithm(**algorithm_params)

    # data
    data_params = _create_data_configuration(
        data_type=data_type,
        axes=axes,
        patch_size=patch_size,
        batch_size=batch_size,
        augmentations=spatial_transforms,
        train_dataloader_params=train_dataloader_params,
        val_dataloader_params=val_dataloader_params,
    )

    # training
    final_trainer_params = update_trainer_params(
        trainer_params=trainer_params,
        num_epochs=num_epochs,
        num_steps=num_steps,
    )
    training_params = _create_training_configuration(
        trainer_params=final_trainer_params,
        logger=logger,
        checkpoint_params=checkpoint_params,
    )

    return Configuration(
        experiment_name=experiment_name,
        algorithm_config=algorithm_config,
        data_config=data_params,
        training_config=training_params,
    )

`get_likelihood_config(loss_type, predict_logvar=None, logvar_lowerbound=-5.0, nm_paths=None, data_stats=None)` #

Get the likelihood configuration for split models.

Returns a tuple containing the following optional entries: - GaussianLikelihoodConfig: Gaussian likelihood configuration for musplit losses - MultiChannelNMConfig: Multi-channel noise model configuration for denoisplit losses - NMLikelihoodConfig: Noise model likelihood configuration for denoisplit losses

Parameters:

Name	Type	Description	Default
`loss_type`	`Literal['musplit', 'denoisplit', 'denoisplit_musplit']`	The type of loss function to use.	required
`predict_logvar`	`Literal['pixelwise'] \| None`	Type of log variance prediction, by default None. Required when loss_type is "musplit" or "denoisplit_musplit".	`None`
`logvar_lowerbound`	`float \| None`	Lower bound for the log variance, by default -5.0. Used when loss_type is "musplit" or "denoisplit_musplit".	`-5.0`
`nm_paths`	`list[str] \| None`	Paths to the noise model files, by default None. Required when loss_type is "denoisplit" or "denoisplit_musplit".	`None`
`data_stats`	`tuple[float, float] \| None`	Data statistics (mean, std), by default None. Required when loss_type is "denoisplit" or "denoisplit_musplit".	`None`

Returns:

Name	Type	Description
`gaussian_lik_config`	`GaussianLikelihoodConfig \| None`	Gaussian likelihood configuration for musplit losses, or None.
`nm_config`	`MultiChannelNMConfig \| None`	Multi-channel noise model configuration for denoisplit losses, or None.
`nm_lik_config`	`NMLikelihoodConfig \| None`	Noise model likelihood configuration for denoisplit losses, or None.

Raises:

Type	Description
`ValueError`	If required parameters are missing for the specified loss_type.

Source code in src/careamics/config/configuration_factories.py

def get_likelihood_config(
    loss_type: Literal["musplit", "denoisplit", "denoisplit_musplit"],
    # TODO remove different microsplit loss types, refac
    predict_logvar: Literal["pixelwise"] | None = None,
    logvar_lowerbound: float | None = -5.0,
    nm_paths: list[str] | None = None,
    data_stats: tuple[float, float] | None = None,
) -> tuple[
    GaussianLikelihoodConfig | None,
    MultiChannelNMConfig | None,
    NMLikelihoodConfig | None,
]:
    """Get the likelihood configuration for split models.

    Returns a tuple containing the following optional entries:
        - GaussianLikelihoodConfig: Gaussian likelihood configuration for musplit losses
        - MultiChannelNMConfig: Multi-channel noise model configuration for denoisplit
        losses
        - NMLikelihoodConfig: Noise model likelihood configuration for denoisplit losses

    Parameters
    ----------
    loss_type : Literal["musplit", "denoisplit", "denoisplit_musplit"]
        The type of loss function to use.
    predict_logvar : Literal["pixelwise"] | None, optional
        Type of log variance prediction, by default None.
        Required when loss_type is "musplit" or "denoisplit_musplit".
    logvar_lowerbound : float | None, optional
        Lower bound for the log variance, by default -5.0.
        Used when loss_type is "musplit" or "denoisplit_musplit".
    nm_paths : list[str] | None, optional
        Paths to the noise model files, by default None.
        Required when loss_type is "denoisplit" or "denoisplit_musplit".
    data_stats : tuple[float, float] | None, optional
        Data statistics (mean, std), by default None.
        Required when loss_type is "denoisplit" or "denoisplit_musplit".

    Returns
    -------
    gaussian_lik_config : GaussianLikelihoodConfig | None
        Gaussian likelihood configuration for musplit losses, or None.
    nm_config : MultiChannelNMConfig | None
        Multi-channel noise model configuration for denoisplit losses, or None.
    nm_lik_config : NMLikelihoodConfig | None
        Noise model likelihood configuration for denoisplit losses, or None.

    Raises
    ------
    ValueError
        If required parameters are missing for the specified loss_type.
    """
    # gaussian likelihood
    if loss_type in ["musplit", "denoisplit_musplit"]:
        # if predict_logvar is None:
        #     raise ValueError(f"predict_logvar is required for '{loss_type}'")
        # TODO validators should be in pydantic models
        gaussian_lik_config = GaussianLikelihoodConfig(
            predict_logvar=predict_logvar,
            logvar_lowerbound=logvar_lowerbound,
        )
    else:
        gaussian_lik_config = None

    # noise model likelihood
    if loss_type in ["denoisplit", "denoisplit_musplit"]:
        # if nm_paths is None:
        #     raise ValueError(f"nm_paths is required for loss_type '{loss_type}'")
        # if data_stats is None:
        #     raise ValueError(f"data_stats is required for loss_type '{loss_type}'")
        # TODO validators should be in pydantic models
        gmm_list = []
        if nm_paths is not None:
            for NM_path in nm_paths:
                gmm_list.append(
                    GaussianMixtureNMConfig(
                        model_type="GaussianMixtureNoiseModel",
                        path=NM_path,
                    )
                )
        noise_model_config = MultiChannelNMConfig(noise_models=gmm_list)
        nm_lik_config = NMLikelihoodConfig()  # TODO this config isn't needed probably
    else:
        noise_model_config = None
        nm_lik_config = None

    return gaussian_lik_config, noise_model_config, nm_lik_config

`update_trainer_params(trainer_params=None, num_epochs=None, num_steps=None)` #

Update trainer parameters with num_epochs and num_steps.

Parameters:

Name	Type	Description	Default
`trainer_params`	`dict`	Parameters for Lightning Trainer class, by default None.	`None`
`num_epochs`	`int`	Number of epochs to train for. If provided, this will be added as max_epochs to trainer_params, by default None.	`None`
`num_steps`	`int`	Number of batches in 1 epoch. If provided, this will be added as limit_train_batches to trainer_params, by default None.	`None`

Returns:

Type	Description
`dict`	Updated trainer parameters dictionary.

Source code in src/careamics/config/configuration_factories.py

def update_trainer_params(
    trainer_params: dict[str, Any] | None = None,
    num_epochs: int | None = None,
    num_steps: int | None = None,
) -> dict[str, Any]:
    """
    Update trainer parameters with num_epochs and num_steps.

    Parameters
    ----------
    trainer_params : dict, optional
        Parameters for Lightning Trainer class, by default None.
    num_epochs : int, optional
        Number of epochs to train for. If provided, this will be added as max_epochs
        to trainer_params, by default None.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added as
        limit_train_batches to trainer_params, by default None.

    Returns
    -------
    dict
        Updated trainer parameters dictionary.
    """
    final_trainer_params = {} if trainer_params is None else trainer_params.copy()

    if num_epochs is not None:
        final_trainer_params["max_epochs"] = num_epochs
    if num_steps is not None:
        final_trainer_params["limit_train_batches"] = num_steps

    return final_trainer_params

configuration_factories

algorithm_factory(algorithm) #

TODO revisit the necessity of model_params#

>>> config = create_microsplit_configuration(#

... experiment_name="microsplit_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... num_epochs=100#

... )#

You can also limit the number of batches per epoch:#

>>> config = create_microsplit_configuration(#

... experiment_name="microsplit_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... num_steps=100 # limit to 100 batches per epoch#

... )#

create_ng_data_configuration(data_type, axes, patch_size, batch_size, augmentations=None, channels=None, in_memory=None, patch_overlaps=None, train_dataloader_params=None, val_dataloader_params=None, pred_dataloader_params=None, seed=None) #

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100#

... )#

You can also limit the number of batches per epoch:#

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_steps=100 # limit to 100 batches per epoch#

... )#

To disable transforms, simply set augmentations to an empty list:#

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... augmentations=[]#

... )#

A list of transforms can be passed to the augmentations parameter:#

>>> from careamics.config.transformations import XYFlipModel#

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v_experiment",#

... data_type="array",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... augmentations=[#

... # No rotation and only Y flipping#

... XYFlipModel(flip_x = False, flip_y = True)#

... ]#

... )#

To use N2V2, simply pass the use_n2v2 parameter:#

>>> config = create_pn2v_configuration(#

... experiment_name="pn2v2_experiment",#

... data_type="tiff",#

... axes="YX",#

... patch_size=[64, 64],#

... batch_size=32,#

... nm_path="path/to/noise_model.npz",#

... num_epochs=100,#

... use_n2v2=True#

... )#

For structN2V, there are two parameters to set, struct_n2v_axis and#

struct_n2v_span:#

>>> config = create_pn2v_configuration(#

`algorithm_factory(algorithm)` #

`create_ng_data_configuration(data_type, axes, patch_size, batch_size, augmentations=None, channels=None, in_memory=None, patch_overlaps=None, train_dataloader_params=None, val_dataloader_params=None, pred_dataloader_params=None, seed=None)` #

To disable transforms, simply set `augmentations` to an empty list:#

A list of transforms can be passed to the `augmentations` parameter:#

To use N2V2, simply pass the `use_n2v2` parameter:#

For structN2V, there are two parameters to set, `struct_n2v_axis` and#

`struct_n2v_span`:#

off the `independent_channels` parameter (resulting in 400 total output#

`get_likelihood_config(loss_type, predict_logvar=None, logvar_lowerbound=-5.0, nm_paths=None, data_stats=None)` #

`update_trainer_params(trainer_params=None, num_epochs=None, num_steps=None)` #