




import dataclasses
import json
import warnings
from dataclasses import dataclass, field
from time import time
from typing import List

from ..utils import logging


_lowerCamelCase      			=						logging.get_logger(__name__)




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						List[str]=None	,					__UpperCamelCase      :						Tuple=None				)  ->							int:
    return field(default_factory=lambda: default	,					metadata=__UpperCamelCase				)



@dataclass
class       a					:

     '''simple docstring'''





     lowerCAmelCase    :	List[str]       		=  list_field(
         default=[]     ,       metadata={
             'help': (
                 'Model checkpoints to be provided to the AutoModel classes. Leave blank to benchmark the base version'
                 ' of all available models'
             )
         }     ,       )

     lowerCAmelCase    :	List[int]       		=  list_field(
         default=[8]     ,       metadata={'help': 'List of batch sizes for which memory and time performance will be evaluated'}      )

     lowerCAmelCase    :	List[int]       		=  list_field(
         default=[8, 32, 128, 512]     ,       metadata={'help': 'List of sequence lengths for which memory and time performance will be evaluated'}     ,       )

     lowerCAmelCase    :	bool       		=  field(
         default=_A     ,       metadata={'help': 'Whether to benchmark inference of model. Inference can be disabled via --no-inference.'}     ,       )
     lowerCAmelCase    :	bool       		=  field(
         default=_A     ,       metadata={'help': 'Whether to run on available cuda devices. Cuda can be disabled via --no-cuda.'}     ,       )
     lowerCAmelCase    :	bool       		=  field(
         default=_A     ,       metadata={'help': 'Whether to run on available tpu devices. TPU can be disabled via --no-tpu.'}      )
     lowerCAmelCase    :	bool       		=  field(default=_A     ,       metadata={'help': 'Use FP16 to accelerate inference.'}      )
     lowerCAmelCase    :	bool       		=  field(default=_A     ,       metadata={'help': 'Benchmark training of model'}      )
     lowerCAmelCase    :	bool       		=  field(default=_A     ,       metadata={'help': 'Verbose memory tracing'}      )
     lowerCAmelCase    :	bool       		=  field(
         default=_A     ,       metadata={'help': 'Whether to perform speed measurements. Speed measurements can be disabled via --no-speed.'}     ,       )
     lowerCAmelCase    :	bool       		=  field(
         default=_A     ,       metadata={
             'help': 'Whether to perform memory measurements. Memory measurements can be disabled via --no-memory'
         }     ,       )
     lowerCAmelCase    :	bool       		=  field(default=_A     ,       metadata={'help': 'Trace memory line by line'}      )
     lowerCAmelCase    :	bool       		=  field(default=_A     ,       metadata={'help': 'Save result to a CSV file'}      )
     lowerCAmelCase    :	bool       		=  field(default=_A     ,       metadata={'help': 'Save all print statements in a log file'}      )
     lowerCAmelCase    :	bool       		=  field(default=_A     ,       metadata={'help': 'Whether to print environment information'}      )
     lowerCAmelCase    :	bool       		=  field(
         default=_A     ,       metadata={
             'help': (
                 'Whether to use multiprocessing for memory and speed measurement. It is highly recommended to use'
                 ' multiprocessing for accurate CPU and GPU memory measurements. This option should only be disabled'
                 ' for debugging / testing and on TPU.'
             )
         }     ,       )
     lowerCAmelCase    :	str       		=  field(
         default=f'''inference_time_{round(time()      )}.csv'''     ,       metadata={'help': 'CSV filename used if saving time results to csv.'}     ,       )
     lowerCAmelCase    :	str       		=  field(
         default=f'''inference_memory_{round(time()      )}.csv'''     ,       metadata={'help': 'CSV filename used if saving memory results to csv.'}     ,       )
     lowerCAmelCase    :	str       		=  field(
         default=f'''train_time_{round(time()      )}.csv'''     ,       metadata={'help': 'CSV filename used if saving time results to csv for training.'}     ,       )
     lowerCAmelCase    :	str       		=  field(
         default=f'''train_memory_{round(time()      )}.csv'''     ,       metadata={'help': 'CSV filename used if saving memory results to csv for training.'}     ,       )
     lowerCAmelCase    :	str       		=  field(
         default=f'''env_info_{round(time()      )}.csv'''     ,       metadata={'help': 'CSV filename used if saving environment information.'}     ,       )
     lowerCAmelCase    :	str       		=  field(
         default=f'''log_{round(time()      )}.csv'''     ,       metadata={'help': 'Log filename used if print statements are saved in log.'}     ,       )
     lowerCAmelCase    :	int       		=  field(default=3     ,       metadata={'help': 'Times an experiment will be run.'}      )
     lowerCAmelCase    :	bool       		=  field(
         default=_A     ,       metadata={
             'help': (
                 'Instead of loading the model as defined in `config.architectures` if exists, just load the pretrain'
                 ' model weights.'
             )
         }     ,       )
     def   lowerCamelCase_       (     self       :      List[str]    ):
         warnings.warn(
             F'The class {self.__class__} is deprecated. Hugging Face Benchmarking utils'
             ''' are deprecated in general and it is advised to use external Benchmarking libraries '''
             ''' to benchmark Transformer models.''' ,   __snake_case ,   )
     def   lowerCamelCase_       (     self       :      Optional[Any]    ):
         return json.dumps(dataclasses.asdict(self    ) ,   indent=2    )
     @property
     def   lowerCamelCase_       (     self       :      Tuple    ):
         if len(self.models    ) <= 0:
             raise ValueError(
                 '''Please make sure you provide at least one model name / model identifier, *e.g.* `--models'''
                 ''' bert-base-cased` or `args.models = [\'bert-base-cased\'].'''    )
         return self.models




     @property
     def   lowerCamelCase_       (     self       :      Tuple    ):
         if not self.multi_process:
             return False
         elif self.is_tpu:
             logger.info('''Multiprocessing is currently not possible on TPU.'''    )
             return False
         else:
             return True











import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


_lowerCamelCase      			=						False



class       a					(       unittest.TestCase      ):

     '''simple docstring'''





     def   lowerCamelCase_       (     self       :      str    ):
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()
     @property
     def   lowerCamelCase_       (     self       :      Any    ):
         return 12
     @property
     def   lowerCamelCase_       (     self       :      Union[str, Any]    ):
         return 12
     @property
     def   lowerCamelCase_       (     self       :      Optional[Any]    ):
         return 32
     @property
     def   lowerCamelCase_       (     self       :      List[Any]    ):
         torch.manual_seed(0    )
         UpperCAmelCase_										=					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 ,   num_vq_embeddings=self.num_embed ,   vq_embed_dim=3 ,   )
         return model
     @property
     def   lowerCamelCase_       (     self       :      Tuple    ):
         UpperCAmelCase_										=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )
         return tokenizer
     @property
     def   lowerCamelCase_       (     self       :      int    ):
         torch.manual_seed(0    )
         UpperCAmelCase_										=					CLIPTextConfig(
             bos_token_id=0 ,   eos_token_id=2 ,   hidden_size=self.text_embedder_hidden_size ,   intermediate_size=37 ,   layer_norm_eps=1E-05 ,   num_attention_heads=4 ,   num_hidden_layers=5 ,   pad_token_id=1 ,   vocab_size=10_00 ,   )
         return CLIPTextModel(__snake_case    )
     @property
     def   lowerCamelCase_       (     self       :      Union[str, Any]    ):
         torch.manual_seed(0    )

         UpperCAmelCase_										=					12
         UpperCAmelCase_										=					12

         UpperCAmelCase_										=					{
             '''attention_bias''': True,
             '''cross_attention_dim''': 32,
             '''attention_head_dim''': height * width,
             '''num_attention_heads''': 1,
             '''num_vector_embeds''': self.num_embed,
             '''num_embeds_ada_norm''': self.num_embeds_ada_norm,
             '''norm_num_groups''': 32,
             '''sample_size''': width,
             '''activation_fn''': '''geglu-approximate''',
         }

         UpperCAmelCase_										=					TransformeraDModel(**__snake_case    )
         return model
     def   lowerCamelCase_       (     self       :      int    ):
         UpperCAmelCase_										=					'''cpu'''

         UpperCAmelCase_										=					self.dummy_vqvae
         UpperCAmelCase_										=					self.dummy_text_encoder
         UpperCAmelCase_										=					self.dummy_tokenizer
         UpperCAmelCase_										=					self.dummy_transformer
         UpperCAmelCase_										=					VQDiffusionScheduler(self.num_embed    )
         UpperCAmelCase_										=					LearnedClassifierFreeSamplingEmbeddings(learnable=__snake_case    )

         UpperCAmelCase_										=					VQDiffusionPipeline(
             vqvae=__snake_case ,   text_encoder=__snake_case ,   tokenizer=__snake_case ,   transformer=__snake_case ,   scheduler=__snake_case ,   learned_classifier_free_sampling_embeddings=__snake_case ,   )
         UpperCAmelCase_										=					pipe.to(__snake_case    )
         pipe.set_progress_bar_config(disable=__snake_case    )

         UpperCAmelCase_										=					'''teddy bear playing in the pool'''

         UpperCAmelCase_										=					torch.Generator(device=__snake_case    ).manual_seed(0    )
         UpperCAmelCase_										=					pipe([prompt] ,   generator=__snake_case ,   num_inference_steps=2 ,   output_type='''np'''    )
         UpperCAmelCase_										=					output.images

         UpperCAmelCase_										=					torch.Generator(device=__snake_case    ).manual_seed(0    )
         UpperCAmelCase_										=					pipe(
             [prompt] ,   generator=__snake_case ,   output_type='''np''' ,   return_dict=__snake_case ,   num_inference_steps=2    )[0]

         UpperCAmelCase_										=					image[0, -3:, -3:, -1]
         UpperCAmelCase_										=					image_from_tuple[0, -3:, -3:, -1]

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

         UpperCAmelCase_										=					np.array([0.6_551, 0.6_168, 0.5_008, 0.5_676, 0.5_659, 0.4_295, 0.6_073, 0.5_599, 0.4_992]    )

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




     def   lowerCamelCase_       (     self       :      str    ):
         UpperCAmelCase_										=					'''cpu'''

         UpperCAmelCase_										=					self.dummy_vqvae
         UpperCAmelCase_										=					self.dummy_text_encoder
         UpperCAmelCase_										=					self.dummy_tokenizer
         UpperCAmelCase_										=					self.dummy_transformer
         UpperCAmelCase_										=					VQDiffusionScheduler(self.num_embed    )
         UpperCAmelCase_										=					LearnedClassifierFreeSamplingEmbeddings(
             learnable=__snake_case ,   hidden_size=self.text_embedder_hidden_size ,   length=tokenizer.model_max_length    )

         UpperCAmelCase_										=					VQDiffusionPipeline(
             vqvae=__snake_case ,   text_encoder=__snake_case ,   tokenizer=__snake_case ,   transformer=__snake_case ,   scheduler=__snake_case ,   learned_classifier_free_sampling_embeddings=__snake_case ,   )
         UpperCAmelCase_										=					pipe.to(__snake_case    )
         pipe.set_progress_bar_config(disable=__snake_case    )

         UpperCAmelCase_										=					'''teddy bear playing in the pool'''

         UpperCAmelCase_										=					torch.Generator(device=__snake_case    ).manual_seed(0    )
         UpperCAmelCase_										=					pipe([prompt] ,   generator=__snake_case ,   num_inference_steps=2 ,   output_type='''np'''    )
         UpperCAmelCase_										=					output.images

         UpperCAmelCase_										=					torch.Generator(device=__snake_case    ).manual_seed(0    )
         UpperCAmelCase_										=					pipe(
             [prompt] ,   generator=__snake_case ,   output_type='''np''' ,   return_dict=__snake_case ,   num_inference_steps=2    )[0]

         UpperCAmelCase_										=					image[0, -3:, -3:, -1]
         UpperCAmelCase_										=					image_from_tuple[0, -3:, -3:, -1]

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

         UpperCAmelCase_										=					np.array([0.6_693, 0.6_075, 0.4_959, 0.5_701, 0.5_583, 0.4_333, 0.6_171, 0.5_684, 0.4_988]    )

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



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

     '''simple docstring'''





     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()




     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         UpperCAmelCase_										=					load_numpy(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
             '''/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy'''    )

         UpperCAmelCase_										=					VQDiffusionPipeline.from_pretrained('''microsoft/vq-diffusion-ithq'''    )
         UpperCAmelCase_										=					pipeline.to(__snake_case    )
         pipeline.set_progress_bar_config(disable=__snake_case    )

         # requires GPU generator for gumbel softmax
         # don't use GPU generator in tests though
         UpperCAmelCase_										=					torch.Generator(device=__snake_case    ).manual_seed(0    )
         UpperCAmelCase_										=					pipeline(
             '''teddy bear playing in the pool''' ,   num_images_per_prompt=1 ,   generator=__snake_case ,   output_type='''np''' ,   )

         UpperCAmelCase_										=					output.images[0]

         assert image.shape == (2_56, 2_56, 3)
         assert np.abs(expected_image - image    ).max() < 2.0





