To

Bases: Transform

Move all data to a device and/or cast to a dtype.

Wraps the to() method as a transform so it can be used inside Compose pipelines.

Parameters:

Name	Type	Description	Default
`*to_args`	`Any`	Positional arguments forwarded to `torch.Tensor.to()`. Typically a device string (`"cpu"`, `"cuda"`, `"mps"`) or a `torch.dtype` (`torch.float16`).	`()`
`**to_kwargs`	`Any`	Keyword arguments forwarded to `torch.Tensor.to()`.	`{}`

Examples:

>>> import torchio as tio
>>> transform = tio.To(torch.float16)
>>> transform = tio.To("cuda")
>>> pipeline = tio.Compose([
...     tio.To("cuda"),
...     tio.Noise(std=0.1),
... ])

Source code in src/torchio/transforms/to.py

class To(Transform):
    """Move all data to a device and/or cast to a dtype.

    Wraps the `to()` method as a transform so it can be used inside
    [`Compose`][torchio.Compose] pipelines.

    Args:
        *to_args: Positional arguments forwarded to
            [`torch.Tensor.to()`](https://pytorch.org/docs/stable/generated/torch.Tensor.to.html).
            Typically a device string (`"cpu"`, `"cuda"`,
            `"mps"`) or a `torch.dtype` (`torch.float16`).
        **to_kwargs: Keyword arguments forwarded to
            `torch.Tensor.to()`.

    Examples:
        >>> import torchio as tio
        >>> transform = tio.To(torch.float16)
        >>> transform = tio.To("cuda")
        >>> pipeline = tio.Compose([
        ...     tio.To("cuda"),
        ...     tio.Noise(std=0.1),
        ... ])
    """

    def __init__(self, *to_args: Any, **to_kwargs: Any) -> None:
        super().__init__()
        self.to_args = to_args
        self.to_kwargs = to_kwargs

    def make_params(self, batch: SubjectsBatch) -> dict[str, Any]:
        return {"to_args": self.to_args, "to_kwargs": self.to_kwargs}

    def apply_transform(
        self,
        batch: SubjectsBatch,
        params: dict[str, Any],
    ) -> SubjectsBatch:
        batch.to(*params["to_args"], **params["to_kwargs"])
        return batch

`supports_per_instance_params` `property`

Whether this transform can sample parameters per batch element.

Defaults to False. Transforms that implement per-instance parameter sampling override this to return True. When False, the transform always uses batch-shared parameters regardless of the per_instance flag, preserving the legacy behavior.

`supports_per_instance_p` `property`

Whether this transform can gate each batch element independently.

Defaults to False. Shape-preserving transforms that implement per-element probability override this to return True. Shape-changing transforms must leave it False because masked and unmasked elements would have incompatible shapes.

`invertible` `property`

Whether this transform can be inverted.

`forward(data)`

forward(data: Subject) -> Subject

forward(data: Image) -> Image

forward(data: Tensor) -> Tensor

forward(data: np.ndarray) -> np.ndarray

forward(data: sitk.Image) -> sitk.Image

forward(data: nib.Nifti1Image) -> nib.Nifti1Image

forward(data: dict) -> dict

forward(data: ImagesBatch) -> ImagesBatch

forward(data: SubjectsBatch) -> SubjectsBatch

Apply the transform.

The output type always matches the input type.

Parameters:

Name	Type	Description	Default
`data`	`Any`	Input data to transform.	required

Source code in src/torchio/transforms/transform.py

def forward(self, data: Any) -> Any:
    """Apply the transform.

    The output type always matches the input type.

    Args:
        data: Input data to transform.
    """
    return self._execute(data, params=None, sample_params=True)

`apply_with_params(data, params)`

apply_with_params(data: Subject, params: dict[str, Any]) -> Subject

apply_with_params(data: Image, params: dict[str, Any]) -> Image

apply_with_params(data: Tensor, params: dict[str, Any]) -> Tensor

apply_with_params(data: np.ndarray, params: dict[str, Any]) -> np.ndarray

apply_with_params(data: sitk.Image, params: dict[str, Any]) -> sitk.Image

apply_with_params(data: nib.Nifti1Image, params: dict[str, Any]) -> nib.Nifti1Image

apply_with_params(data: dict, params: dict[str, Any]) -> dict

apply_with_params(data: ImagesBatch, params: dict[str, Any]) -> ImagesBatch

apply_with_params(data: SubjectsBatch, params: dict[str, Any]) -> SubjectsBatch

Apply an exact parameter set without sampling.

This method bypasses the transform probability and make_params(), but otherwise follows the normal transform lifecycle: copy handling, input wrapping, output-type restoration, and history recording.

Parameters:

Name	Type	Description	Default
`data`	`Any`	Input data to transform.	required
`params`	`dict[str, Any]`	Exact parameters accepted by `apply_transform`.	required

Returns:

Type	Description
`Any`	Transformed data with the same type as the input.

Raises:

Type	Description
`TypeError`	If `params` is not a dictionary.
`NotImplementedError`	If the transform does not expose one exact-parameter kernel.
`ValueError`	If per-instance parameter dimensions do not match the input batch.

Source code in src/torchio/transforms/transform.py

def apply_with_params(
    self,
    data: Any,
    params: dict[str, Any],
) -> Any:
    """Apply an exact parameter set without sampling.

    This method bypasses the transform probability and
    [`make_params()`][torchio.Transform.make_params], but otherwise
    follows the normal transform lifecycle: copy handling, input
    wrapping, output-type restoration, and history recording.

    Args:
        data: Input data to transform.
        params: Exact parameters accepted by `apply_transform`.

    Returns:
        Transformed data with the same type as the input.

    Raises:
        TypeError: If `params` is not a dictionary.
        NotImplementedError: If the transform does not expose one
            exact-parameter kernel.
        ValueError: If per-instance parameter dimensions do not
            match the input batch.
    """
    if not self._supports_apply_with_params:
        msg = (
            f"{type(self).__name__}.apply_with_params() is not supported"
            " because this transform does not expose a single"
            " make_params/apply_transform parameter kernel."
        )
        raise NotImplementedError(msg)
    if not isinstance(params, dict):
        msg = f"Expected params to be a dict, got {type(params).__name__}"
        raise TypeError(msg)
    return self._execute(
        data,
        params=_copy.deepcopy(params),
        sample_params=False,
    )

`inverse(params)`

Return a transform that undoes this one.

Override in invertible subclasses. The returned transform, when applied, reverses the effect of the forward pass with the given parameters.

Parameters:

Name	Type	Description	Default
`params`	`dict[str, Any]`	The parameters recorded in the forward pass.	required

Returns:

Type	Description
`Transform`	A new `Transform` instance that inverts this one.

Source code in src/torchio/transforms/transform.py

def inverse(self, params: dict[str, Any]) -> Transform:
    """Return a transform that undoes this one.

    Override in invertible subclasses. The returned transform,
    when applied, reverses the effect of the forward pass with
    the given parameters.

    Args:
        params: The parameters recorded in the forward pass.

    Returns:
        A new `Transform` instance that inverts this one.
    """
    msg = f"{type(self).__name__} is not invertible"
    raise NotImplementedError(msg)

`to_hydra()`

Export as a Hydra-compatible config dict.

Returns a dict with _target_ set to the fully qualified class name and only non-default field values included.

Returns:

Type	Description
`dict[str, Any]`	Dict suitable for `hydra.utils.instantiate()`.

Source code in src/torchio/transforms/transform.py

def to_hydra(self) -> dict[str, Any]:
    """Export as a Hydra-compatible config dict.

    Returns a dict with `_target_` set to the fully qualified
    class name and only non-default field values included.

    Returns:
        Dict suitable for `hydra.utils.instantiate()`.
    """
    from .parameter_range import _ParameterRange

    cls = type(self)
    target = f"torchio.{cls.__qualname__}"
    cfg: dict[str, Any] = {"_target_": target}

    for name, default in _collect_init_params(cls).items():
        value = getattr(self, name, default)
        if isinstance(value, _ParameterRange):
            if value._original == default:
                continue
            value = _hydra_value(value._original)
        elif value == default:
            continue
        else:
            value = _hydra_value(value)
        cfg[name] = value
    return cfg

To

supports_per_instance_params property

supports_per_instance_p property

invertible property

forward(data)

apply_with_params(data, params)

inverse(params)

to_hydra()

`supports_per_instance_params` `property`

`supports_per_instance_p` `property`

`invertible` `property`

`forward(data)`

`apply_with_params(data, params)`

`inverse(params)`

`to_hydra()`