BiasField

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)
    # When per-element gating is active, the transform handles the
    # probability itself (masked-out elements get identity params),
    # so skip the batch-wide coin flip here. Apply iff rand < p, so
    # p=0 is always a no-op and p=1 always applies.
    if not self._per_instance_p_active(batch) and 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, unless every element was gated out by
    # per-element probability: that is an exact no-op, and recording it
    # would let history replay (e.g. an invertible spatial transform)
    # trigger an unnecessary identity resample.
    if not _all_elements_gated_out(params):
        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

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

def make_params(self, batch: SubjectsBatch) -> dict[str, Any]:
    """Sample the bias field standard deviation (per element when batched)."""
    n = self._resolve_n(batch)
    if n is None:
        std = self.std.sample_1d()
        seed = int(torch.randint(0, 2**31, (1,)).item())
        return {
            "std": std,
            "seed": seed,
            "scale": self.scale,
        }
    keep = self._keep_mask(batch, n)
    std = self._mask_identity(self.std.sample_1d(n), keep, identity=0.0)
    # A per-element seed makes each element's field reproducible from its
    # own recorded parameters, so it inverts correctly after unbatching.
    seeds = [int(torch.randint(0, 2**31, (1,)).item()) for _ in range(n)]
    params = {
        "std": self._serialize_param(std),
        "seed": seeds,
        "scale": self.scale,
    }
    self._tag_batched(params, batch, n, keep, ["std", "seed"])
    return params

def apply_transform(
    self,
    batch: SubjectsBatch,
    params: dict[str, Any],
) -> SubjectsBatch:
    """Multiply each selected image by a smooth random bias field."""
    std = params["std"]
    seed = params["seed"]
    scale = params["scale"]

    per_instance = self._is_per_instance_params(params)
    if not per_instance and std == 0:
        return batch

    for _name, img_batch in self._get_images(batch).items():
        if per_instance:
            img_batch.data = _apply_bias_per_element(
                img_batch.data,
                std,
                seed,
                scale,
                divide=False,
            )
        else:
            field = _generate_bias_field(
                img_batch.data.shape,
                std=std,
                scale=scale,
                seed=seed,
                device=img_batch.data.device,
            )
            img_batch.data = img_batch.data * field

    return batch

def inverse(self, params: dict[str, Any]) -> _BiasFieldInverse:
    """Build the inverse by dividing by the same bias field."""
    return _BiasFieldInverse(
        std=params["std"],
        seed=params["seed"],
        scale=params["scale"],
        copy=False,
    )