def set_seed(seed: int) -> None:
    """
    Sets the random seed for reproducibility.

    Parameters
    ----------
    seed : int
        The seed value to set for random number generation.

    Examples
    --------
    >>> set_seed(42)
    """

    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(seed)

def human_readable(num: float) -> str:
    """
    Converts a large number into a human-readable string using
    K, M, G, T suffixes.

    Parameters
    ----------
    num : float
        Number to be converted

    Returns
    -------
    str
        Human-readable converted number.

    Examples
    --------
    >>> human_readable(1_500)
    '1.500K'
    >>> human_readable(2_300_000)
    '2.300M'
    >>> human_readable(42)
    '42.000'
    """
    for unit in ["", "K", "M", "G", "T", "P"]:
        if abs(num) < 1000:
            return f"{num:.3f}{unit}"
        num /= 1000
    return f"{num:.3f}"

def check_shape(
        array: Union[np.ndarray, torch.Tensor],
        expected_shape: Union[Tuple[int, ...], List[Tuple[int, ...]]]
    ) -> None:
    """
    Validates that an input array matches one or more expected shapes.
    Dimensions may be integers or `-1`, where `-1` acts as a wildcard.

    Parameters
    ----------
    array : Union[np.ndarray, torch.Tensor]
        Input array to validate.

    expected_shape : Union[Tuple[int, ...], List[Tuple[int, ...]]]
        A single expected shape or a list of acceptable shapes.
        Use `-1` or `None` to indicate a wildcard dimension.

    Examples
    --------
    >>> x = np.zeros((4, 8))
    >>> check_shape(x, (4, 8))  # exact match
    >>> check_shape(x, (-1, 8))  # wildcard batch dimension
    >>> check_shape(x, [(-1, 4), (-1, 8)])  # multiple acceptable shapes
    """
    # Type check
    if not isinstance(array, (np.ndarray, torch.Tensor)):
        logger.error(
            f"Invalid type: expected `np.ndarray` or `torch.Tensor`, "
            f"got `{type(array).__name__}`", TypeError
        )

    actual_shape = tuple(array.shape)

    if isinstance(expected_shape, tuple):
        expected_shapes = [expected_shape]
    else:
        expected_shapes = expected_shape

    # Try all possible shapes
    for shape in expected_shapes:
        if len(shape) != len(actual_shape):
            continue

        match = True
        for a, e in zip(actual_shape, shape):
            if e not in (-1, None) and a != e:
                match = False
                break

        # Valid shape found
        if match:
            return

    # If no match found
    if isinstance(expected_shape, tuple):
        logger.error(
            f"Invalid shape: expected `{expected_shape}`, "
            f"got `{actual_shape}`", ValueError
        )

    else:
        logger.error(
            f"expected one of `{expected_shapes}`, "
            f"got `{actual_shape}`", ValueError
        )