Function assert_close

python/paddle/testing/_comparison.py:876–1062

r""" Asserts that ``actual`` and ``expected`` are close. If ``actual`` and ``expected`` are real-valued, and finite, they are considered close if .. math:: \lvert \text{actual} - \text{expected} \rvert \le \texttt{atol} + \texttt{rtol} \cdot \lvert \text{expected} \rvert

(
    actual: Any,
    expected: Any,
    *,
    allow_subclasses: bool = True,
    rtol: float | None = None,
    atol: float | None = None,
    equal_nan: bool = False,
    check_device: bool = True,
    check_dtype: bool = True,
    msg: str | Callable[[str], str] | None = None,
)

def assert_close(
    actual: Any,
    expected: Any,
    *,
    allow_subclasses: bool = True,
    rtol: float | None = None,
    atol: float | None = None,
    equal_nan: bool = False,
    check_device: bool = True,
    check_dtype: bool = True,
    msg: str | Callable[[str], str] | None = None,
) -> None:
    r"""
    Asserts that ``actual`` and ``expected`` are close.

    If ``actual`` and ``expected`` are real-valued, and finite, they are considered close if

    .. math::

        \lvert \text{actual} - \text{expected} \rvert \le \texttt{atol} + \texttt{rtol} \cdot \lvert \text{expected} \rvert

    Non-finite values (``-inf`` and ``inf``) are only considered close if and only if they are equal. ``NaN``'s are
    only considered equal to each other if ``equal_nan`` is ``True``.

    In addition, they are only considered close if they have the same

    - :attr:`~paddle.Tensor.place` (if ``check_device`` is ``True``),
    - ``dtype`` (if ``check_dtype`` is ``True``),

    In static graph mode, only the check_dtype attribute verification will be performed.

    ``actual`` and ``expected`` can be :class:`~paddle.Tensor`'s or any tensor-or-scalar-likes from which
    :class:`paddle.Tensor`'s can be constructed with :func:`paddle.to_tensor`. Except for Python scalars the input types
    have to be directly related. In addition, ``actual`` and ``expected`` can be :class:`~collections.abc.Sequence`'s
    or :class:`~collections.abc.Mapping`'s in which case they are considered close if their structure matches and all
    their elements are considered close according to the above definition.

    .. note::

        Python scalars are an exception to the type relation requirement, because their :func:`type`, i.e.
        :class:`int`, :class:`float`, and :class:`complex`, is equivalent to the ``dtype`` of a tensor-like. Thus,
        Python scalars of different types can be checked, but require ``check_dtype=False``.

    Args:
        actual (Any): Actual input.
        expected (Any): Expected input.
        allow_subclasses (bool): If ``True`` (default) and except for Python scalars, inputs of directly related types
            are allowed. Otherwise type equality is required.
        rtol (float, optional): Relative tolerance. If specified ``atol`` must also be specified. If omitted, default
            values based on the :attr:`~paddle.Tensor.dtype` are selected with the below table.
        atol (float, optional): Absolute tolerance. If specified ``rtol`` must also be specified. If omitted, default
            values based on the :attr:`~paddle.Tensor.dtype` are selected with the below table.
        equal_nan (bool|str, optional): If ``True``, two ``NaN`` values will be considered equal.
        check_device (bool): If ``True`` (default), asserts that corresponding tensors are on the same
            :attr:`~paddle.Tensor.place`. If this check is disabled, tensors on different
            :attr:`~paddle.Tensor.place`'s are moved to the CPU before being compared.
        check_dtype (bool): If ``True`` (default), asserts that corresponding tensors have the same ``dtype``. If this
            check is disabled, tensors with different ``dtype``'s are promoted to a common ``dtype`` before being compared.