careamics 0.0.19__py3-none-any.whl

careamics/config/ng_factories/algorithm_factory.py

@@ -0,0 +1,120 @@
+"""Convenience function to create algorithm configurations."""
+
+from typing import Annotated, Any, Literal, Union
+
+from pydantic import Field, TypeAdapter
+
+from careamics.config.algorithms import (
+    CAREAlgorithm,
+    N2NAlgorithm,
+    N2VAlgorithm,
+    # PN2VAlgorithm,  # TODO not yet compatible with NG Dataset
+)
+from careamics.config.architectures import UNetConfig
+from careamics.config.support.supported_architectures import SupportedArchitecture
+
+
+# TODO rename so that it does not bear the same name as the module?
+def algorithm_factory(
+    algorithm: dict[str, Any],
+) -> Union[N2VAlgorithm, N2NAlgorithm, CAREAlgorithm]:
+    """
+    Create an algorithm model for training CAREamics.
+
+    Parameters
+    ----------
+    algorithm : dict
+        Algorithm dictionary.
+
+    Returns
+    -------
+    N2VAlgorithm or N2NAlgorithm or CAREAlgorithm
+        Algorithm model for training CAREamics.
+    """
+    adapter: TypeAdapter = TypeAdapter(
+        Annotated[
+            Union[N2VAlgorithm, N2NAlgorithm, CAREAlgorithm],
+            Field(discriminator="algorithm"),
+        ]
+    )
+    return adapter.validate_python(algorithm)
+
+
+def create_algorithm_configuration(
+    dimensions: Literal[2, 3],
+    algorithm: Literal["n2v", "care", "n2n"],
+    loss: Literal["n2v", "mae", "mse"],
+    independent_channels: bool,
+    n_channels_in: int,
+    n_channels_out: int,
+    use_n2v2: bool = False,
+    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,
+) -> dict:
+    """
+    Create a dictionary with the parameters of the algorithm model.
+
+    Parameters
+    ----------
+    dimensions : {2, 3}
+        Dimension of the model, either 2D or 3D.
+    algorithm : {"n2v", "care", "n2n"}
+        Algorithm to use.
+    loss : {"n2v", "mae", "mse"}
+        Loss function to use.
+    independent_channels : bool
+        Whether to train all channels independently.
+    n_channels_in : int
+        Number of input channels.
+    n_channels_out : int
+        Number of output channels.
+    use_n2v2 : bool, default=false
+        Whether to use N2V2.
+    model_params : dict, default=None
+        UNetModel parameters.
+    optimizer : {"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 : {"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.
+
+
+    Returns
+    -------
+    dict
+        Algorithm model as dictionnary with the specified parameters.
+    """
+    # create dictionary to ensure priority of explicit parameters over model_params
+    # and prevent multiple same parameters being passed to UNetConfig
+    model_params = {} if model_params is None else model_params
+    model_params["n2v2"] = use_n2v2
+    model_params["conv_dims"] = dimensions
+    model_params["in_channels"] = n_channels_in
+    model_params["num_classes"] = n_channels_out
+    model_params["independent_channels"] = independent_channels
+
+    unet_model = UNetConfig(
+        architecture=SupportedArchitecture.UNET.value,
+        **model_params,
+    )
+
+    return {
+        "algorithm": algorithm,
+        "loss": loss,
+        "model": unet_model,
+        "optimizer": {
+            "name": optimizer,
+            "parameters": {} if optimizer_params is None else optimizer_params,
+        },
+        "lr_scheduler": {
+            "name": lr_scheduler,
+            "parameters": {} if lr_scheduler_params is None else lr_scheduler_params,
+        },
+    }

careamics/config/ng_factories/data_factory.py

@@ -0,0 +1,154 @@
+"""Convenience functions to create NG data configurations."""
+
+from collections.abc import Sequence
+from typing import Any, Literal
+
+from careamics.config.data import NGDataConfig
+from careamics.config.transformations import (
+    SPATIAL_TRANSFORMS_UNION,
+    XYFlipConfig,
+    XYRandomRotate90Config,
+)
+
+
+def list_spatial_augmentations(
+    augmentations: list[SPATIAL_TRANSFORMS_UNION] | None = None,
+) -> list[SPATIAL_TRANSFORMS_UNION]:
+    """
+    List the augmentations to apply.
+
+    Parameters
+    ----------
+    augmentations : list of transforms, optional
+        List of transforms to apply, either both or one of XYFlipConfig and
+        XYRandomRotate90Config.
+
+    Returns
+    -------
+    list of transforms
+        List of transforms to apply.
+
+    Raises
+    ------
+    ValueError
+        If the transforms are not XYFlipConfig or XYRandomRotate90Config.
+    ValueError
+        If there are duplicate transforms.
+    """
+    if augmentations is None:
+        transform_list: list[SPATIAL_TRANSFORMS_UNION] = [
+            XYFlipConfig(),
+            XYRandomRotate90Config(),
+        ]
+    else:
+        # throw error if not all transforms are pydantic models
+        if not all(
+            isinstance(t, XYFlipConfig) or isinstance(t, XYRandomRotate90Config)
+            for t in augmentations
+        ):
+            raise ValueError(
+                "Accepted transforms are either XYFlipConfig or "
+                "XYRandomRotate90Config."
+            )
+
+        # check that there is no duplication
+        aug_types = [t.__class__ for t in augmentations]
+        if len(set(aug_types)) != len(aug_types):
+            raise ValueError("Duplicate transforms are not allowed.")
+
+        transform_list = augmentations
+
+    return transform_list
+
+
+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,
+    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).
+    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,
+    }
+
+    return NGDataConfig(**data)

careamics/config/ng_factories/n2v_factory.py

@@ -0,0 +1,256 @@
+"""Convenience function to create N2V configurations."""
+
+from collections.abc import Sequence
+from typing import Any, Literal
+
+from careamics.config.ng_configs import N2VConfiguration
+from careamics.config.support import (
+    SupportedPixelManipulation,
+    SupportedTransform,
+)
+from careamics.config.transformations import (
+    N2VManipulateConfig,
+    XYFlipConfig,
+    XYRandomRotate90Config,
+)
+
+from .algorithm_factory import create_algorithm_configuration
+from .data_factory import create_ng_data_configuration, list_spatial_augmentations
+from .training_factory import create_training_configuration, update_trainer_params
+
+
+def create_n2v_configuration(
+    experiment_name: str,
+    data_type: Literal["array", "tiff", "zarr", "czi", "custom"],
+    axes: str,
+    patch_size: Sequence[int],
+    batch_size: int,
+    num_epochs: int = 100,
+    num_steps: int | None = None,
+    augmentations: list[XYFlipConfig | XYRandomRotate90Config] | None = None,
+    channels: Sequence[int] | None = None,
+    in_memory: bool | 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,
+) -> N2VConfiguration:
+    """
+    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.
+    channels : Sequence of int, optional
+        List of channels to use. If `None`, all channels are used.
+    in_memory : bool, optional
+        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`.
+    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). If `channels` is specified, then the number of
+        channels is inferred from its length.
+    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
+    -------
+    N2VConfiguration
+        Configuration for training N2V.
+    """
+    # if there are channels, we need to specify their number
+    channels_present = "C" in axes
+
+    if channels_present and (n_channels is None and channels is None):
+        raise ValueError(
+            "`n_channels` or `channels` must be specified when using channels."
+        )
+    elif not channels_present 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 not None and channels is not None:
+        if n_channels != len(channels):
+            raise ValueError(
+                f"Number of channels ({n_channels}) does not match length of "
+                f"`channels` ({len(channels)}). Only specify `channels`."
+            )
+
+    if n_channels is None:
+        n_channels = 1 if channels is None else len(channels)
+
+    # augmentations
+    spatial_transforms = list_spatial_augmentations(augmentations)
+
+    # data
+    data_config = create_ng_data_configuration(
+        data_type=data_type,
+        axes=axes,
+        patch_size=patch_size,
+        batch_size=batch_size,
+        augmentations=spatial_transforms,
+        channels=channels,
+        in_memory=in_memory,
+        train_dataloader_params=train_dataloader_params,
+        val_dataloader_params=val_dataloader_params,
+    )
+
+    # algorithm
+    algorithm_params = create_algorithm_configuration(
+        dimensions=3 if data_config.is_3D() else 2,
+        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,
+    )
+
+    # 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_params["n2v_config"] = n2v_transform
+
+    # 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 N2VConfiguration(
+        experiment_name=experiment_name,
+        algorithm_config=algorithm_params,
+        data_config=data_config,
+        training_config=training_params,
+    )

careamics/config/ng_factories/training_factory.py

@@ -0,0 +1,69 @@
+"""Convenience functions to create training configurations."""
+
+from typing import Any, Literal
+
+from careamics.config.lightning.training_config import TrainingConfig
+
+
+def create_training_configuration(
+    trainer_params: dict,
+    logger: Literal["wandb", "tensorboard", "none"],
+    checkpoint_params: dict[str, Any] | None = None,
+) -> TrainingConfig:
+    """
+    Create a dictionary with the parameters of the training model.
+
+    Parameters
+    ----------
+    trainer_params : dict
+        Parameters for Lightning Trainer class, see PyTorch Lightning documentation.
+    logger : {"wandb", "tensorboard", "none"}
+        Logger to use.
+    checkpoint_params : dict, default=None
+        Parameters for the checkpoint callback, see PyTorch Lightning documentation
+        (`ModelCheckpoint`) for the list of available parameters.
+
+    Returns
+    -------
+    TrainingConfig
+        Training model with the specified parameters.
+    """
+    return TrainingConfig(
+        lightning_trainer_config=trainer_params,
+        logger=None if logger == "none" else logger,
+        checkpoint_callback={} if checkpoint_params is None else checkpoint_params,
+    )
+
+
+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

careamics/config/noise_model/__init__.py

@@ -0,0 +1,12 @@
+"""Noise models Pydantic configurations."""
+
+__all__ = [
+    "GaussianLikelihoodConfig",
+    "GaussianMixtureNMConfig",
+    "MultiChannelNMConfig",
+    "NMLikelihoodConfig",
+]
+
+
+from .likelihood_config import GaussianLikelihoodConfig, NMLikelihoodConfig
+from .noise_model_config import GaussianMixtureNMConfig, MultiChannelNMConfig

careamics/config/noise_model/likelihood_config.py

@@ -0,0 +1,60 @@
+"""Likelihood model."""
+
+from typing import Annotated, Literal, Union
+
+import numpy as np
+import torch
+from pydantic import BaseModel, ConfigDict, PlainSerializer, PlainValidator
+
+from careamics.models.lvae.noise_models import (
+    GaussianMixtureNoiseModel,
+    MultiChannelNoiseModel,
+)
+from careamics.utils.serializers import _array_to_json, _to_torch
+
+NoiseModel = Union[GaussianMixtureNoiseModel, MultiChannelNoiseModel]
+
+# TODO: this is a temporary solution to serialize and deserialize tensor fields
+# in pydantic models. Specifically, the aim is to enable saving and loading configs
+# with such tensors to/from JSON files during, resp., training and evaluation.
+Tensor = Annotated[
+    Union[np.ndarray, torch.Tensor],
+    PlainSerializer(_array_to_json, return_type=str),
+    PlainValidator(_to_torch),
+]
+"""Annotated tensor type, used to serialize arrays or tensors to JSON strings
+and deserialize them back to tensors."""
+
+
+class GaussianLikelihoodConfig(BaseModel):
+    """Gaussian likelihood configuration."""
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    predict_logvar: Literal["pixelwise"] | None = None
+    """If `pixelwise`, log-variance is computed for each pixel, else log-variance
+    is not computed."""
+
+    logvar_lowerbound: Union[float, None] = None
+    """The lowerbound value for log-variance."""
+
+
+class NMLikelihoodConfig(BaseModel):
+    """Noise model likelihood configuration.
+
+    NOTE: we need to define the data mean and std here because the noise model
+    is trained on not-normalized data. Hence, we need to unnormalize the model
+    output to compute the noise model likelihood.
+    """
+
+    model_config = ConfigDict(validate_assignment=True, arbitrary_types_allowed=True)
+
+    # TODO remove and use as parameters to the likelihood functions?
+    data_mean: Tensor | None = None
+    """The mean of the data, used to unnormalize data for noise model evaluation.
+    Shape is (target_ch,) (or (1, target_ch, [1], 1, 1))."""
+
+    # TODO remove and use as parameters to the likelihood functions?
+    data_std: Tensor | None = None
+    """The standard deviation of the data, used to unnormalize data for noise
+    model evaluation. Shape is (target_ch,) (or (1, target_ch, [1], 1, 1))."""