'''simple docstring'''

import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()



class       UpperCAmelCase  (						snake_case__   ,						snake_case__   ,						snake_case__   ,						unittest.TestCase ):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE 		=   StableUnCLIPPipeline
       SCREAMING_SNAKE_CASE 		=   TEXT_TO_IMAGE_PARAMS
       SCREAMING_SNAKE_CASE 		=   TEXT_TO_IMAGE_BATCH_PARAMS
       SCREAMING_SNAKE_CASE 		=   TEXT_TO_IMAGE_IMAGE_PARAMS
       SCREAMING_SNAKE_CASE 		=   TEXT_TO_IMAGE_IMAGE_PARAMS

       # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
       SCREAMING_SNAKE_CASE 		=   False

       def _lowerCAmelCase(						self			)  ->  Optional[int]:
        lowercase__    :   str						= 32
        lowercase__    :   int						= embedder_hidden_size

        # prior components

        torch.manual_seed(0			)
        lowercase__    :   List[str]						= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			)

        torch.manual_seed(0			)
        lowercase__    :   Tuple						= CLIPTextModelWithProjection(
            CLIPTextConfig(
                bos_token_id=0     ,       eos_token_id=2     ,       hidden_size=UpperCAmelCase_     ,       projection_dim=UpperCAmelCase_     ,       intermediate_size=37     ,       layer_norm_eps=1E-05     ,       num_attention_heads=4     ,       num_hidden_layers=5     ,       pad_token_id=1     ,       vocab_size=1000     ,       )			)

        torch.manual_seed(0			)
        lowercase__    :   Any						= PriorTransformer(
            num_attention_heads=2     ,       attention_head_dim=12     ,       embedding_dim=UpperCAmelCase_     ,       num_layers=1     ,       )

        torch.manual_seed(0			)
        lowercase__    :   Any						= DDPMScheduler(
            variance_type='''fixed_small_log'''     ,       prediction_type='''sample'''     ,       num_train_timesteps=1000     ,       clip_sample=UpperCAmelCase_     ,       clip_sample_range=5.0     ,       beta_schedule='''squaredcos_cap_v2'''     ,       )

        # regular denoising components

        torch.manual_seed(0			)
        lowercase__    :   Any						= StableUnCLIPImageNormalizer(embedding_dim=UpperCAmelCase_			)
        lowercase__    :   int						= DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''			)

        torch.manual_seed(0			)
        lowercase__    :   int						= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			)

        torch.manual_seed(0			)
        lowercase__    :   Dict						= CLIPTextModel(
            CLIPTextConfig(
                bos_token_id=0     ,       eos_token_id=2     ,       hidden_size=UpperCAmelCase_     ,       projection_dim=32     ,       intermediate_size=37     ,       layer_norm_eps=1E-05     ,       num_attention_heads=4     ,       num_hidden_layers=5     ,       pad_token_id=1     ,       vocab_size=1000     ,       )			)

        torch.manual_seed(0			)
        lowercase__    :   Optional[int]						= UNetaDConditionModel(
            sample_size=32     ,       in_channels=4     ,       out_channels=4     ,       down_block_types=('''CrossAttnDownBlock2D''', '''DownBlock2D''')     ,       up_block_types=('''UpBlock2D''', '''CrossAttnUpBlock2D''')     ,       block_out_channels=(32, 64)     ,       attention_head_dim=(2, 4)     ,       class_embed_type='''projection'''     ,       projection_class_embeddings_input_dim=embedder_projection_dim * 2     ,       cross_attention_dim=UpperCAmelCase_     ,       layers_per_block=1     ,       upcast_attention=UpperCAmelCase_     ,       use_linear_projection=UpperCAmelCase_     ,       )

        torch.manual_seed(0			)
        lowercase__    :   Optional[Any]						= DDIMScheduler(
            beta_schedule='''scaled_linear'''     ,       beta_start=0.0_0_0_8_5     ,       beta_end=0.0_1_2     ,       prediction_type='''v_prediction'''     ,       set_alpha_to_one=UpperCAmelCase_     ,       steps_offset=1     ,       )

        torch.manual_seed(0			)
        lowercase__    :   List[str]						= AutoencoderKL()

        lowercase__    :   Optional[int]						= {
            # prior components
            "prior_tokenizer": prior_tokenizer,
            "prior_text_encoder": prior_text_encoder,
            "prior": prior,
            "prior_scheduler": prior_scheduler,
            # image noising components
            "image_normalizer": image_normalizer,
            "image_noising_scheduler": image_noising_scheduler,
            # regular denoising components
            "tokenizer": tokenizer,
            "text_encoder": text_encoder,
            "unet": unet,
            "scheduler": scheduler,
            "vae": vae,
        }

        return components

       def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase=0			)  ->  Dict:
        if str(UpperCAmelCase_			).startswith('''mps'''			):
         lowercase__    :   Union[str, Any]						= torch.manual_seed(UpperCAmelCase_			)
        else:
         lowercase__    :   Dict						= torch.Generator(device=UpperCAmelCase_			).manual_seed(UpperCAmelCase_			)
        lowercase__    :   Optional[int]						= {
            "prompt": "A painting of a squirrel eating a burger",
            "generator": generator,
            "num_inference_steps": 2,
            "prior_num_inference_steps": 2,
            "output_type": "numpy",
        }
        return inputs

       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   Any						= torch_device == "cpu"

        self._test_attention_slicing_forward_pass(test_max_difference=UpperCAmelCase_			)


       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   List[Any]						= torch_device in ["cpu", "mps"]

        self._test_inference_batch_single_identical(test_max_difference=UpperCAmelCase_			)



@slow
@require_torch_gpu
class       UpperCAmelCase  (						unittest.TestCase ):





       '''simple docstring'''



       def _lowerCAmelCase(						self			)  ->  List[Any]:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()

       def _lowerCAmelCase(						self			)  ->  Tuple:
        lowercase__    :   Tuple						= load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'''			)

        lowercase__    :   Tuple						= StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''     ,       torch_dtype=torch.floataa			)
        pipe.to(UpperCAmelCase_			)
        pipe.set_progress_bar_config(disable=UpperCAmelCase_			)
        # stable unclip will oom when integration tests are run on a V100,
        # so turn on memory savings
        pipe.enable_attention_slicing()
        pipe.enable_sequential_cpu_offload()

        lowercase__    :   Dict						= torch.Generator(device='''cpu'''			).manual_seed(0			)
        lowercase__    :   Union[str, Any]						= pipe('''anime turle'''     ,       generator=UpperCAmelCase_     ,       output_type='''np'''			)

        lowercase__    :   List[str]						= output.images[0]

        assert image.shape == (768, 768, 3)

        assert_mean_pixel_difference(UpperCAmelCase_     ,       UpperCAmelCase_			)


       def _lowerCAmelCase(						self			)  ->  Tuple:
        torch.cuda.empty_cache()
        torch.cuda.reset_max_memory_allocated()
        torch.cuda.reset_peak_memory_stats()

        lowercase__    :   Optional[int]						= StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''     ,       torch_dtype=torch.floataa			)
        lowercase__    :   Optional[int]						= pipe.to(UpperCAmelCase_			)
        pipe.set_progress_bar_config(disable=UpperCAmelCase_			)
        pipe.enable_attention_slicing()
        pipe.enable_sequential_cpu_offload()

        lowercase__    :   Union[str, Any]						= pipe(
            '''anime turtle'''     ,       prior_num_inference_steps=2     ,       num_inference_steps=2     ,       output_type='''np'''     ,       )

        lowercase__    :   List[Any]						= torch.cuda.max_memory_allocated()
        # make sure that less than 7 GB is allocated
        assert mem_bytes < 7 * 10**9


'''simple docstring'''

import qiskit
def       __UpperCamelCase	(       UpperCAmelCase		,					UpperCAmelCase					):
 lowercase__    :   Dict						= qiskit.Aer.get_backend('''aer_simulator'''					)

 # Create a Quantum Circuit acting on the q register
 lowercase__    :   Any						= qiskit.QuantumCircuit(UpperCAmelCase		,					UpperCAmelCase					)

 # Map the quantum measurement to the classical bits
 circuit.measure([0]		,					[0]					)

 # Execute the circuit on the simulator
 lowercase__    :   Any						= qiskit.execute(UpperCAmelCase		,					UpperCAmelCase		,					shots=1000					)

 # Return the histogram data of the results of the experiment.
 return job.result().get_counts(UpperCAmelCase					)


if __name__ == "__main__":
  print(F'Total count for various states are: {single_qubit_measure(1, 1)}')

