def METHOD_NAME(
    net: torch.nn.Module,
    metrics: dict[str, Metric] | None = None,
    devices: Sequence[str | torch.device] | None = None,
    non_blocking: bool = False,
    prepare_batch: Callable = _prepare_batch,
    output_transform: Callable = _default_eval_transform,
    distributed: bool = False,
) -> Engine:
    """
    Derived from `create_supervised_evaluator` in Ignite.
    Factory function for creating an evaluator for supervised models.
    Args:
        net: the model to train.
        metrics: a map of metric names to Metrics.
        devices: device(s) type specification (default: None).
            Applies to both model and batches. None is all devices used, empty list is CPU only.
        non_blocking: if True and this copy is between CPU and GPU, the copy may occur asynchronously
            with respect to the host. For other cases, this argument has no effect.
        prepare_batch: function that receives `batch`, `device`, `non_blocking` and outputs
            tuple of tensors `(batch_x, batch_y)`.
        output_transform: function that receives 'x', 'y', 'y_pred' and returns value
            to be assigned to engine's state.output after each iteration. Default is returning `(y_pred, y,)`
            which fits output expected by metrics. If you change it you should use `output_transform` in metrics.
        distributed: whether convert model to `DistributedDataParallel`, if `True`, `devices` must contain
            only 1 GPU or CPU for current distributed rank.
    Note:
        `engine.state.output` for this engine is defined by `output_transform` parameter and is
        a tuple of `(batch_pred, batch_y)` by default.
    Returns:
        Engine: an evaluator engine with supervised inference function.
    """
    devices_ = get_devices_spec(devices)
    if distributed:
        net = DistributedDataParallel(net, device_ids=devices_)
        if len(devices_) > 1:
            raise ValueError(
                f"for distributed evaluation, `devices` must contain only 1 GPU or CPU, but got {devices_}."
            )
    elif len(devices_) > 1:
        net = DataParallel(net)
    return create_supervised_evaluator(  # type: ignore[no-any-return]
        model=net,
        metrics=metrics,
        device=devices_[0],
        non_blocking=non_blocking,
        prepare_batch=prepare_batch,
        output_transform=output_transform,
    )