Bases: Transform
Apply a user-defined function as a transform.
The callable receives and returns a 4D tensor (C, I, J, K).
Use types_to_apply to restrict which image types are affected.
Parameters:
| Name |
Type |
Description |
Default |
function
|
Callable[[Tensor], Tensor]
|
|
required
|
types_to_apply
|
str | None
|
Which image types the function applies to.
"scalar" for ScalarImage only,
"label" for LabelMap only,
None for all images.
|
None
|
**kwargs
|
Any
|
|
{}
|
Examples:
>>> import torchio as tio
>>> invert = tio.Lambda(lambda x: -x, types_to_apply="scalar")
>>> double = tio.Lambda(lambda x: 2 * x)
>>> threshold = tio.Lambda(lambda x: (x > 0.5).float(), types_to_apply="label")
Source code in src/torchio/transforms/lambda_transform.py
| class Lambda(Transform):
"""Apply a user-defined function as a transform.
The callable receives and returns a 4D tensor `(C, I, J, K)`.
Use *types_to_apply* to restrict which image types are affected.
Args:
function: Callable that receives and returns a 4D
[`torch.Tensor`][torch.Tensor].
types_to_apply: Which image types the function applies to.
`"scalar"` for [`ScalarImage`][torchio.ScalarImage] only,
`"label"` for [`LabelMap`][torchio.LabelMap] only,
`None` for all images.
**kwargs: See [`Transform`][torchio.Transform].
Examples:
>>> import torchio as tio
>>> invert = tio.Lambda(lambda x: -x, types_to_apply="scalar")
>>> double = tio.Lambda(lambda x: 2 * x)
>>> threshold = tio.Lambda(lambda x: (x > 0.5).float(), types_to_apply="label")
"""
def __init__(
self,
function: Callable[[Tensor], Tensor],
types_to_apply: str | None = None,
**kwargs: Any,
) -> None:
super().__init__(**kwargs)
if not callable(function):
msg = f"function must be callable, got {type(function).__name__}"
raise TypeError(msg)
self.function = function
self.types_to_apply = types_to_apply
def make_params(self, batch: SubjectsBatch) -> dict[str, Any]:
"""No random parameters."""
return {}
def apply_transform(
self,
batch: SubjectsBatch,
params: dict[str, Any],
) -> SubjectsBatch:
"""Apply the callable to each matching image."""
for _name, img_batch in batch.images.items():
if not self._should_apply(img_batch._image_class):
continue
for i in range(img_batch.batch_size):
img_batch.data[i] = self.function(img_batch.data[i])
return batch
def _should_apply(self, image_class: type) -> bool:
"""Check whether this image type should be transformed."""
if self.types_to_apply is None:
return True
if self.types_to_apply == "scalar":
return issubclass(image_class, ScalarImage)
if self.types_to_apply == "label":
return issubclass(image_class, LabelMap)
return True
|
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
|
|
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.
"""
if self.copy:
data = _copy.deepcopy(data)
batch, unwrap = self._wrap(data)
if torch.rand(1).item() > self.p:
return unwrap(batch)
params = self.make_params(batch)
batch = self.apply_transform(batch, params)
# Record history on the batch
trace = AppliedTransform(name=type(self).__name__, params=params)
if not hasattr(batch, "applied_transforms"):
batch.applied_transforms = []
batch.applied_transforms.append(trace)
result = unwrap(batch)
# Propagate history to outputs that can carry it
if (
hasattr(batch, "applied_transforms")
and not isinstance(result, (SubjectsBatch, Tensor, np.ndarray))
and not isinstance(result, dict)
):
with contextlib.suppress(AttributeError):
result.applied_transforms = list(batch.applied_transforms)
return result
|
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
|
make_params(batch)
No random parameters.
Source code in src/torchio/transforms/lambda_transform.py
| def make_params(self, batch: SubjectsBatch) -> dict[str, Any]:
"""No random parameters."""
return {}
|
Apply the callable to each matching image.
Source code in src/torchio/transforms/lambda_transform.py
| def apply_transform(
self,
batch: SubjectsBatch,
params: dict[str, Any],
) -> SubjectsBatch:
"""Apply the callable to each matching image."""
for _name, img_batch in batch.images.items():
if not self._should_apply(img_batch._image_class):
continue
for i in range(img_batch.batch_size):
img_batch.data[i] = self.function(img_batch.data[i])
return batch
|