



'''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        lowerCAmelCase_(				SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_						, unittest.TestCase     ):
  '''simple docstring'''




  __lowercase							:      int				=      StableUnCLIPPipeline
  __lowercase							:      str				=      TEXT_TO_IMAGE_PARAMS
  __lowercase							:      List[Any]				=      TEXT_TO_IMAGE_BATCH_PARAMS
  __lowercase							:      Optional[Any]				=      TEXT_TO_IMAGE_IMAGE_PARAMS
  __lowercase							:      Optional[Any]				=      TEXT_TO_IMAGE_IMAGE_PARAMS

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




  def 							UpperCAmelCase_	(    self      )    ->		List[str]:
      lowerCAmelCase__ :  Optional[Any]							      =					32
      lowerCAmelCase__ :  Optional[int]							      =					embedder_hidden_size

      # prior components

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

      torch.manual_seed(0      )
      lowerCAmelCase__ :  Any							      =					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      )
      lowerCAmelCase__ :  List[str]							      =					PriorTransformer(
          num_attention_heads=2  ,attention_head_dim=12  ,embedding_dim=__UpperCAmelCase  ,num_layers=1  ,)

      torch.manual_seed(0      )
      lowerCAmelCase__ :  Tuple							      =					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      )
      lowerCAmelCase__ :  Dict							      =					StableUnCLIPImageNormalizer(embedding_dim=__UpperCAmelCase      )
      lowerCAmelCase__ :  Any							      =					DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""      )

      torch.manual_seed(0      )
      lowerCAmelCase__ :  Dict							      =					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""      )

      torch.manual_seed(0      )
      lowerCAmelCase__ :  int							      =					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      )
      lowerCAmelCase__ :  str							      =					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      )
      lowerCAmelCase__ :  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      )
      lowerCAmelCase__ :  List[str]							      =					AutoencoderKL()

      lowerCAmelCase__ :  List[str]							      =					{
          # 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 							UpperCAmelCase_	(    self  ,__UpperCAmelCase  ,__UpperCAmelCase=0      )    ->		Any:
      if str(__UpperCAmelCase      ).startswith("""mps"""      ):
          lowerCAmelCase__ :  int							      =					torch.manual_seed(__UpperCAmelCase      )
      else:
          lowerCAmelCase__ :  Any							      =					torch.Generator(device=__UpperCAmelCase      ).manual_seed(__UpperCAmelCase      )
      lowerCAmelCase__ :  Any							      =					{
          """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 							UpperCAmelCase_	(    self      )    ->		Optional[int]:
      lowerCAmelCase__ :  Tuple							      =					torch_device == """cpu"""

      self._test_attention_slicing_forward_pass(test_max_difference=__UpperCAmelCase      )






  def 							UpperCAmelCase_	(    self      )    ->		Union[str, Any]:
      lowerCAmelCase__ :  List[str]							      =					torch_device in ["""cpu""", """mps"""]

      self._test_inference_batch_single_identical(test_max_difference=__UpperCAmelCase      )







@slow
@require_torch_gpu
class        lowerCAmelCase_(				unittest.TestCase     ):
  '''simple docstring'''




  def 							UpperCAmelCase_	(    self      )    ->		str:
      # clean up the VRAM after each test
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()




  def 							UpperCAmelCase_	(    self      )    ->		Optional[Any]:
      lowerCAmelCase__ :  Union[str, Any]							      =					load_numpy(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"""      )

      lowerCAmelCase__ :  Optional[Any]							      =					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()

      lowerCAmelCase__ :  Union[str, Any]							      =					torch.Generator(device="""cpu"""      ).manual_seed(0      )
      lowerCAmelCase__ :  Tuple							      =					pipe("""anime turle"""  ,generator=__UpperCAmelCase  ,output_type="""np"""      )

      lowerCAmelCase__ :  str							      =					output.images[0]

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

      assert_mean_pixel_difference(__UpperCAmelCase  ,__UpperCAmelCase      )






  def 							UpperCAmelCase_	(    self      )    ->		Any:
      torch.cuda.empty_cache()
      torch.cuda.reset_max_memory_allocated()
      torch.cuda.reset_peak_memory_stats()

      lowerCAmelCase__ :  int							      =					StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""  ,torch_dtype=torch.floataa      )
      lowerCAmelCase__ :  List[str]							      =					pipe.to(__UpperCAmelCase      )
      pipe.set_progress_bar_config(disable=__UpperCAmelCase      )
      pipe.enable_attention_slicing()
      pipe.enable_sequential_cpu_offload()

      lowerCAmelCase__ :  Tuple							      =					pipe(
          """anime turtle"""  ,prior_num_inference_steps=2  ,num_inference_steps=2  ,output_type="""np"""  ,)

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







'''simple docstring'''





from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__      ,   lowerCAmelCase__ :  List[str]							      =					analyze_text(UpperCamelCase			)
    lowerCAmelCase__ :  Optional[int]							      =					list(""" """ + ascii_lowercase			)
    # what is our total sum of probabilities.
    lowerCAmelCase__ :  List[Any]							      =					sum(single_char_strings.values()			)

    # one length string
    lowerCAmelCase__ :  Optional[int]							      =					0
    # for each alpha we go in our dict and if it is in it we calculate entropy
    for ch in my_alphas:
        if ch in single_char_strings:
            lowerCAmelCase__ :  List[Any]							      =					single_char_strings[ch]
            lowerCAmelCase__ :  List[Any]							      =					my_str / all_sum
            my_fir_sum += prob * math.loga(UpperCamelCase			)  # entropy formula.

    # print entropy
    print(f"""{round(-1 * my_fir_sum			):.1f}"""			)

    # two len string
    lowerCAmelCase__ :  Dict							      =					sum(two_char_strings.values()			)
    lowerCAmelCase__ :  int							      =					0
    # for each alpha (two in size) calculate entropy.
    for cha in my_alphas:
        for cha in my_alphas:
            lowerCAmelCase__ :  Union[str, Any]							      =					cha + cha
            if sequence in two_char_strings:
                lowerCAmelCase__ :  Dict							      =					two_char_strings[sequence]
                lowerCAmelCase__ :  Tuple							      =					int(UpperCamelCase			) / all_sum
                my_sec_sum += prob * math.loga(UpperCamelCase			)

    # print second entropy
    print(f"""{round(-1 * my_sec_sum			):.1f}"""			)

    # print the difference between them
    print(f"""{round((-1 * my_sec_sum) - (-1 * my_fir_sum)			):.1f}"""			)
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  Optional[Any]							      =					Counter()  # type: ignore
    lowerCAmelCase__ :  Tuple							      =					Counter()  # type: ignore
    single_char_strings[text[-1]] += 1

    # first case when we have space at start.
    two_char_strings[" " + text[0]] += 1
    for i in range(0							,    len(UpperCamelCase			) - 1			):
        single_char_strings[text[i]] += 1
        two_char_strings[text[i : i + 2]] += 1
    return single_char_strings, two_char_strings
def    _SCREAMING_SNAKE_CASE  (       ):



    """simple docstring"""





    import doctest

    doctest.testmod()
    # text = (
    #     "Had repulsive dashwoods suspicion sincerity but advantage now him. Remark "
    #     "easily garret nor nay. Civil those mrs enjoy shy fat merry. You greatest "
    #     "jointure saw horrible. He private he on be imagine suppose. Fertile "
    #     "beloved evident through no service elderly is. Blind there if every no so "
    #     "at. Own neglected you preferred way sincerity delivered his attempted. To "
    #     "of message cottage windows do besides against uncivil.  Delightful "
    #     "unreserved impossible few estimating men favourable see entreaties. She "
    #     "propriety immediate was improving. He or entrance humoured likewise "
    #     "moderate. Much nor game son say feel. Fat make met can must form into "
    #     "gate. Me we offending prevailed discovery. "
    # )

    # calculate_prob(text)


if __name__ == "__main__":
 main()


