
"""simple docstring"""


import os

from packaging import version

from .. import __version__
from .accelerate_utils import apply_forward_hook
from .constants import (
    CONFIG_NAME,
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    DIFFUSERS_DYNAMIC_MODULE_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    ONNX_EXTERNAL_WEIGHTS_NAME,
    ONNX_WEIGHTS_NAME,
    SAFETENSORS_WEIGHTS_NAME,
    TEXT_ENCODER_ATTN_MODULE,
    WEIGHTS_NAME,
)
from .deprecation_utils import deprecate
from .doc_utils import replace_example_docstring
from .dynamic_modules_utils import get_class_from_dynamic_module
from .hub_utils import (
    HF_HUB_OFFLINE,
    _add_variant,
    _get_model_file,
    extract_commit_hash,
    http_user_agent,
)
from .import_utils import (
    BACKENDS_MAPPING,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    DummyObject,
    OptionalDependencyNotAvailable,
    is_accelerate_available,
    is_accelerate_version,
    is_bsa_available,
    is_flax_available,
    is_ftfy_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_omegaconf_available,
    is_onnx_available,
    is_safetensors_available,
    is_scipy_available,
    is_tensorboard_available,
    is_tf_available,
    is_torch_available,
    is_torch_version,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    is_wandb_available,
    is_xformers_available,
    requires_backends,
)
from .logging import get_logger
from .outputs import BaseOutput
from .pil_utils import PIL_INTERPOLATION, numpy_to_pil, pt_to_pil
from .torch_utils import is_compiled_module, randn_tensor


if is_torch_available():
			from .testing_utils import (
			    floats_tensor,
			    load_hf_numpy,
			    load_image,
			    load_numpy,
			    load_pt,
			    nightly,
			    parse_flag_from_env,
			    print_tensor_test,
			    require_torch_a,
			    require_torch_gpu,
			    skip_mps,
			    slow,
			    torch_all_close,
			    torch_device,
			)
			from .torch_utils import maybe_allow_in_graph

from .testing_utils import export_to_gif, export_to_video


__A 		= get_logger(__name__)



def 					_lowerCamelCase(__UpperCamelCase )       ->				str:
	if version.parse(__UpperCamelCase ) < version.parse(__UpperCamelCase ):
		if "dev" in min_version:
			_lowerCAmelCase			=(
			    """This example requires a source install from HuggingFace diffusers (see """
			    """`https://huggingface.co/docs/diffusers/installation#install-from-source`),"""
			)
		else:
			_lowerCAmelCase			=F'''This example requires a minimum version of {min_version},'''
		error_message += F''' but the version found is {__version__}.\n'''
		raise ImportError(__UpperCamelCase )





"""simple docstring"""


from typing import Dict, Optional, Tuple

import torch



def 					_lowerCamelCase(__UpperCamelCase )       ->				torch.Tensor:
	_lowerCAmelCase			=boundaries[1] - boundaries[0]
	_lowerCAmelCase			=boundaries + step / 2
	_lowerCAmelCase			=torch.cat([bin_centers, (bin_centers[-1] + step).unsqueeze(-1 )]					,				dim=0 )
	return bin_centers



def 					_lowerCamelCase(__UpperCamelCase					,				__UpperCamelCase					,				)       ->				Tuple[torch.Tensor, torch.Tensor]:
	_lowerCAmelCase			=_calculate_bin_centers(__UpperCamelCase )
	return (
	    torch.sum(aligned_distance_error_probs * bin_centers					,				dim=-1 ),
	    bin_centers[-1],
	)



def 					_lowerCamelCase(__UpperCamelCase					,				__UpperCamelCase = 31					,				__UpperCamelCase = 64					,				**__UpperCamelCase					,				)       ->				Dict[str, torch.Tensor]:
	_lowerCAmelCase			=torch.linspace(0					,				__UpperCamelCase					,				steps=(no_bins - 1)					,				device=logits.device )

	_lowerCAmelCase			=torch.nn.functional.softmax(__UpperCamelCase					,				dim=-1 )
	_lowerCAmelCase		,							_lowerCAmelCase			=_calculate_expected_aligned_error(
	    alignment_confidence_breaks=__UpperCamelCase					,				aligned_distance_error_probs=__UpperCamelCase					,				)

	return {
	    "aligned_confidence_probs": aligned_confidence_probs,
	    "predicted_aligned_error": predicted_aligned_error,
	    "max_predicted_aligned_error": max_predicted_aligned_error,
	}



def 					_lowerCamelCase(__UpperCamelCase					,				__UpperCamelCase = None					,				__UpperCamelCase = 31					,				__UpperCamelCase = 64					,				__UpperCamelCase = 1E-8					,				**__UpperCamelCase					,				)       ->				torch.Tensor:
	if residue_weights is None:
		_lowerCAmelCase			=logits.new_ones(logits.shape[-2] )

	_lowerCAmelCase			=torch.linspace(0					,				__UpperCamelCase					,				steps=(no_bins - 1)					,				device=logits.device )

	_lowerCAmelCase			=_calculate_bin_centers(__UpperCamelCase )
	torch.sum(__UpperCamelCase )
	_lowerCAmelCase			=logits.shape[-2]
	_lowerCAmelCase			=max(__UpperCamelCase					,				19 )

	_lowerCAmelCase			=1.24 * (clipped_n - 15) ** (1.0 / 3) - 1.8

	_lowerCAmelCase			=torch.nn.functional.softmax(__UpperCamelCase					,				dim=-1 )

	_lowerCAmelCase			=1.0 / (1 + (bin_centers**2) / (da**2))
	_lowerCAmelCase			=torch.sum(probs * tm_per_bin					,				dim=-1 )

	_lowerCAmelCase			=residue_weights / (eps + residue_weights.sum())
	_lowerCAmelCase			=torch.sum(predicted_tm_term * normed_residue_mask					,				dim=-1 )

	_lowerCAmelCase			=per_alignment * residue_weights

	_lowerCAmelCase			=(weighted == torch.max(__UpperCamelCase )).nonzero()[0]
	return per_alignment[tuple(__UpperCamelCase )]



