




'''simple docstring'''




from typing import Dict, Optional, Tuple

import torch




def 						snake_case__    ( lowerCamelCase__				:   torch.Tensor			)   ->   torch.Tensor:
					A_ :     Dict =							boundaries[1] - boundaries[0]
					A_ :     List[Any] =							boundaries + step / 2
					A_ :     Optional[Any] =							torch.cat([bin_centers, (bin_centers[-1] + step).unsqueeze(-1			)]			,		dim=0			)
					return bin_centers




def 						snake_case__    ( lowerCamelCase__				:   torch.Tensor			,		lowerCamelCase__				:   torch.Tensor			,		)   ->   Tuple[torch.Tensor, torch.Tensor]:
					A_ :     Tuple =							_calculate_bin_centers(lowerCamelCase__			)
					return (
					    torch.sum(aligned_distance_error_probs * bin_centers			,		dim=-1			),
					    bin_centers[-1],
					)




def 						snake_case__    ( lowerCamelCase__				:   torch.Tensor			,		lowerCamelCase__				:   int = 3_1			,		lowerCamelCase__				:   int = 6_4			,		**lowerCamelCase__				:   int			,		)   ->   Dict[str, torch.Tensor]:
					A_ :     Any =							torch.linspace(0			,		lowerCamelCase__			,		steps=(no_bins - 1)			,		device=logits.device			)

					A_ :     Dict =							torch.nn.functional.softmax(lowerCamelCase__			,		dim=-1			)
					A_ ,A_ :     int =							_calculate_expected_aligned_error(
					    alignment_confidence_breaks=lowerCamelCase__			,		aligned_distance_error_probs=lowerCamelCase__			,		)

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





def 						snake_case__    ( lowerCamelCase__				:   torch.Tensor			,		lowerCamelCase__				:   Optional[torch.Tensor] = None			,		lowerCamelCase__				:   int = 3_1			,		lowerCamelCase__				:   int = 6_4			,		lowerCamelCase__				:   float = 1e-8			,		**lowerCamelCase__				:   Dict			,		)   ->   torch.Tensor:
					if residue_weights is None:
										A_ :     List[str] =							logits.new_ones(logits.shape[-2]			)

					A_ :     Tuple =							torch.linspace(0			,		lowerCamelCase__			,		steps=(no_bins - 1)			,		device=logits.device			)

					A_ :     str =							_calculate_bin_centers(lowerCamelCase__			)
					torch.sum(lowerCamelCase__			)
					A_ :     str =							logits.shape[-2]
					A_ :     Optional[int] =							max(lowerCamelCase__			,		1_9			)

					A_ :     Tuple =							1.24 * (clipped_n - 1_5) ** (1.0 / 3) - 1.8

					A_ :     List[Any] =							torch.nn.functional.softmax(lowerCamelCase__			,		dim=-1			)

					A_ :     List[Any] =							1.0 / (1 + (bin_centers**2) / (da**2))
					A_ :     str =							torch.sum(probs * tm_per_bin			,		dim=-1			)

					A_ :     str =							residue_weights / (eps + residue_weights.sum())
					A_ :     Dict =							torch.sum(predicted_tm_term * normed_residue_mask			,		dim=-1			)

					A_ :     Tuple =							per_alignment * residue_weights

					A_ :     str =							(weighted == torch.max(lowerCamelCase__			)).nonzero()[0]
					return per_alignment[tuple(lowerCamelCase__			)]









'''simple docstring'''




import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch


enable_full_determinism()






class     UpperCamelCase_     (unittest.TestCase     ):







						"""simple docstring"""


						@property
						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     Dict =							1
											A_ :     Any =							3
											A_ :     Any =							(32, 32)

											A_ :     Dict =							floats_tensor((batch_size, num_channels) + sizes							, rng=random.Random(0    )    ).to(_lowerCamelCase    )
											return image







						@property
						def       _a    (     self      :       Dict    ):





											"""simple docstring"""







											torch.manual_seed(0    )
											A_ :     Optional[int] =							UNetaDModel(
											    block_out_channels=(32, 64)							, layers_per_block=2							, sample_size=32							, in_channels=6							, out_channels=3							, down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')							, up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')							, )
											return model







						@property
						def       _a    (     self      :       Any    ):





											"""simple docstring"""







											torch.manual_seed(0    )
											A_ :     Dict =							VQModel(
											    block_out_channels=[32, 64]							, in_channels=3							, out_channels=3							, down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']							, up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']							, latent_channels=3							, )
											return model







						def       _a    (     self      :       List[Any]    ):





											"""simple docstring"""







											A_ :     Any =							'''cpu'''
											A_ :     Optional[Any] =							self.dummy_uncond_unet
											A_ :     str =							DDIMScheduler()
											A_ :     Optional[int] =							self.dummy_vq_model

											A_ :     Optional[Any] =							LDMSuperResolutionPipeline(unet=_lowerCamelCase							, vqvae=_lowerCamelCase							, scheduler=_lowerCamelCase    )
											ldm.to(_lowerCamelCase    )
											ldm.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     Any =							self.dummy_image.to(_lowerCamelCase    )

											A_ :     str =							torch.Generator(device=_lowerCamelCase    ).manual_seed(0    )
											A_ :     List[Any] =							ldm(image=_lowerCamelCase							, generator=_lowerCamelCase							, num_inference_steps=2							, output_type='''numpy'''    ).images

											A_ :     str =							image[0, -3:, -3:, -1]

											assert image.shape == (1, 64, 64, 3)
											A_ :     List[Any] =							np.array([0.86_78, 0.82_45, 0.63_81, 0.68_30, 0.43_85, 0.55_99, 0.46_41, 0.62_01, 0.51_50]    )

											assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2







						@unittest.skipIf(torch_device != '''cuda'''							, '''This test requires a GPU'''    )
						def       _a    (     self      :       Optional[int]    ):





											"""simple docstring"""







											A_ :     Tuple =							self.dummy_uncond_unet
											A_ :     List[str] =							DDIMScheduler()
											A_ :     str =							self.dummy_vq_model

											# put models in fp16
											A_ :     List[Any] =							unet.half()
											A_ :     Optional[int] =							vqvae.half()

											A_ :     Optional[Any] =							LDMSuperResolutionPipeline(unet=_lowerCamelCase							, vqvae=_lowerCamelCase							, scheduler=_lowerCamelCase    )
											ldm.to(_lowerCamelCase    )
											ldm.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     Optional[Any] =							self.dummy_image.to(_lowerCamelCase    )

											A_ :     Optional[Any] =							ldm(_lowerCamelCase							, num_inference_steps=2							, output_type='''numpy'''    ).images

											assert image.shape == (1, 64, 64, 3)






@slow
@require_torch
class     UpperCamelCase_     (unittest.TestCase     ):







						"""simple docstring"""


						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     Optional[int] =							load_image(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											    '''/vq_diffusion/teddy_bear_pool.png'''    )
											A_ :     List[str] =							init_image.resize((64, 64)							, resample=PIL_INTERPOLATION['''lanczos''']    )

											A_ :     List[str] =							LDMSuperResolutionPipeline.from_pretrained('''duongna/ldm-super-resolution'''							, device_map='''auto'''    )
											ldm.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     List[str] =							torch.manual_seed(0    )
											A_ :     str =							ldm(image=_lowerCamelCase							, generator=_lowerCamelCase							, num_inference_steps=20							, output_type='''numpy'''    ).images

											A_ :     str =							image[0, -3:, -3:, -1]

											assert image.shape == (1, 256, 256, 3)
											A_ :     Optional[Any] =							np.array([0.76_44, 0.76_79, 0.76_42, 0.76_33, 0.76_66, 0.75_60, 0.74_25, 0.72_57, 0.69_07]    )

											assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2



