import gc
import random
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()



class     _A   (    unittest.TestCase							):






  def 		_a					(self	)		->      Optional[Any]:





       '''simple docstring'''





       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()






  @property
  def 		_a					(self	)		->      Any:





       '''simple docstring'''





       UpperCamelCase__										=      1
       UpperCamelCase__										=      3
       UpperCamelCase__										=      (32, 32)

       UpperCamelCase__										=      floats_tensor((batch_size, num_channels) + sizes   ,				rng=random.Random(0	)	).to(SCREAMING_SNAKE_CASE_	)
       return image






  @property
  def 		_a					(self	)		->      Tuple:





       '''simple docstring'''





       torch.manual_seed(0	)
       UpperCamelCase__										=      UNetaDConditionModel(
           block_out_channels=(32, 32, 64)   ,				layers_per_block=2   ,				sample_size=32   ,				in_channels=7   ,				out_channels=4   ,				down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''', '''CrossAttnDownBlock2D''')   ,				up_block_types=('''CrossAttnUpBlock2D''', '''CrossAttnUpBlock2D''', '''UpBlock2D''')   ,				cross_attention_dim=32   ,				attention_head_dim=8   ,				use_linear_projection=SCREAMING_SNAKE_CASE_   ,				only_cross_attention=(True, True, False)   ,				num_class_embeds=100   ,				)
       return model






  @property
  def 		_a					(self	)		->      Any:





       '''simple docstring'''





       torch.manual_seed(0	)
       UpperCamelCase__										=      AutoencoderKL(
           block_out_channels=[32, 32, 64]   ,				in_channels=3   ,				out_channels=3   ,				down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''', '''DownEncoderBlock2D''']   ,				up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''', '''UpDecoderBlock2D''']   ,				latent_channels=4   ,				)
       return model






  @property
  def 		_a					(self	)		->      Optional[Any]:





       '''simple docstring'''





       torch.manual_seed(0	)
       UpperCamelCase__										=      CLIPTextConfig(
           bos_token_id=0   ,				eos_token_id=2   ,				hidden_size=32   ,				intermediate_size=37   ,				layer_norm_eps=1E-05   ,				num_attention_heads=4   ,				num_hidden_layers=5   ,				pad_token_id=1   ,				vocab_size=1000   ,				hidden_act='''gelu'''   ,				projection_dim=512   ,				)
       return CLIPTextModel(SCREAMING_SNAKE_CASE_	)






  def 		_a					(self	)		->      Tuple:





       '''simple docstring'''





       UpperCamelCase__										=      '''cpu'''  # ensure determinism for the device-dependent torch.Generator
       UpperCamelCase__										=      self.dummy_cond_unet_upscale
       UpperCamelCase__										=      DDPMScheduler()
       UpperCamelCase__										=      DDIMScheduler(prediction_type='''v_prediction'''	)
       UpperCamelCase__										=      self.dummy_vae
       UpperCamelCase__										=      self.dummy_text_encoder
       UpperCamelCase__										=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)

       UpperCamelCase__										=      self.dummy_image.cpu().permute(0   ,				2   ,				3   ,				1	)[0]
       UpperCamelCase__										=      Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE_	)	).convert('''RGB'''	).resize((64, 64)	)

       # make sure here that pndm scheduler skips prk
       UpperCamelCase__										=      StableDiffusionUpscalePipeline(
           unet=SCREAMING_SNAKE_CASE_   ,				low_res_scheduler=SCREAMING_SNAKE_CASE_   ,				scheduler=SCREAMING_SNAKE_CASE_   ,				vae=SCREAMING_SNAKE_CASE_   ,				text_encoder=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_   ,				max_noise_level=350   ,				)
       UpperCamelCase__										=      sd_pipe.to(SCREAMING_SNAKE_CASE_	)
       sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

       UpperCamelCase__										=      '''A painting of a squirrel eating a burger'''
       UpperCamelCase__										=      torch.Generator(device=SCREAMING_SNAKE_CASE_	).manual_seed(0	)
       UpperCamelCase__										=      sd_pipe(
           [prompt]   ,				image=SCREAMING_SNAKE_CASE_   ,				generator=SCREAMING_SNAKE_CASE_   ,				guidance_scale=6.0   ,				noise_level=20   ,				num_inference_steps=2   ,				output_type='''np'''   ,				)

       UpperCamelCase__										=      output.images

       UpperCamelCase__										=      torch.Generator(device=SCREAMING_SNAKE_CASE_	).manual_seed(0	)
       UpperCamelCase__										=      sd_pipe(
           [prompt]   ,				image=SCREAMING_SNAKE_CASE_   ,				generator=SCREAMING_SNAKE_CASE_   ,				guidance_scale=6.0   ,				noise_level=20   ,				num_inference_steps=2   ,				output_type='''np'''   ,				return_dict=SCREAMING_SNAKE_CASE_   ,				)[0]

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

       UpperCamelCase__										=      low_res_image.size[0] * 4
       assert image.shape == (1, expected_height_width, expected_height_width, 3)
       UpperCamelCase__										=      np.array([0.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661]	)

       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 		_a					(self	)		->      List[Any]:





       '''simple docstring'''





       UpperCamelCase__										=      '''cpu'''  # ensure determinism for the device-dependent torch.Generator
       UpperCamelCase__										=      self.dummy_cond_unet_upscale
       UpperCamelCase__										=      DDPMScheduler()
       UpperCamelCase__										=      DDIMScheduler(prediction_type='''v_prediction'''	)
       UpperCamelCase__										=      self.dummy_vae
       UpperCamelCase__										=      self.dummy_text_encoder
       UpperCamelCase__										=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)

       UpperCamelCase__										=      self.dummy_image.cpu().permute(0   ,				2   ,				3   ,				1	)[0]
       UpperCamelCase__										=      Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE_	)	).convert('''RGB'''	).resize((64, 64)	)

       # make sure here that pndm scheduler skips prk
       UpperCamelCase__										=      StableDiffusionUpscalePipeline(
           unet=SCREAMING_SNAKE_CASE_   ,				low_res_scheduler=SCREAMING_SNAKE_CASE_   ,				scheduler=SCREAMING_SNAKE_CASE_   ,				vae=SCREAMING_SNAKE_CASE_   ,				text_encoder=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_   ,				max_noise_level=350   ,				)
       UpperCamelCase__										=      sd_pipe.to(SCREAMING_SNAKE_CASE_	)
       sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

       UpperCamelCase__										=      '''A painting of a squirrel eating a burger'''
       UpperCamelCase__										=      sd_pipe(
           2 * [prompt]   ,				image=2 * [low_res_image]   ,				guidance_scale=6.0   ,				noise_level=20   ,				num_inference_steps=2   ,				output_type='''np'''   ,				)
       UpperCamelCase__										=      output.images
       assert image.shape[0] == 2

       UpperCamelCase__										=      torch.Generator(device=SCREAMING_SNAKE_CASE_	).manual_seed(0	)
       UpperCamelCase__										=      sd_pipe(
           [prompt]   ,				image=SCREAMING_SNAKE_CASE_   ,				generator=SCREAMING_SNAKE_CASE_   ,				num_images_per_prompt=2   ,				guidance_scale=6.0   ,				noise_level=20   ,				num_inference_steps=2   ,				output_type='''np'''   ,				)
       UpperCamelCase__										=      output.images
       assert image.shape[0] == 2






  @unittest.skipIf(torch_device != '''cuda'''   ,				'''This test requires a GPU'''	)
  def 		_a					(self	)		->      Any:





       '''simple docstring'''





       UpperCamelCase__										=      self.dummy_cond_unet_upscale
       UpperCamelCase__										=      DDPMScheduler()
       UpperCamelCase__										=      DDIMScheduler(prediction_type='''v_prediction'''	)
       UpperCamelCase__										=      self.dummy_vae
       UpperCamelCase__										=      self.dummy_text_encoder
       UpperCamelCase__										=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)

       UpperCamelCase__										=      self.dummy_image.cpu().permute(0   ,				2   ,				3   ,				1	)[0]
       UpperCamelCase__										=      Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE_	)	).convert('''RGB'''	).resize((64, 64)	)

       # put models in fp16, except vae as it overflows in fp16
       UpperCamelCase__										=      unet.half()
       UpperCamelCase__										=      text_encoder.half()

       # make sure here that pndm scheduler skips prk
       UpperCamelCase__										=      StableDiffusionUpscalePipeline(
           unet=SCREAMING_SNAKE_CASE_   ,				low_res_scheduler=SCREAMING_SNAKE_CASE_   ,				scheduler=SCREAMING_SNAKE_CASE_   ,				vae=SCREAMING_SNAKE_CASE_   ,				text_encoder=SCREAMING_SNAKE_CASE_   ,				tokenizer=SCREAMING_SNAKE_CASE_   ,				max_noise_level=350   ,				)
       UpperCamelCase__										=      sd_pipe.to(SCREAMING_SNAKE_CASE_	)
       sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

       UpperCamelCase__										=      '''A painting of a squirrel eating a burger'''
       UpperCamelCase__										=      torch.manual_seed(0	)
       UpperCamelCase__										=      sd_pipe(
           [prompt]   ,				image=SCREAMING_SNAKE_CASE_   ,				generator=SCREAMING_SNAKE_CASE_   ,				num_inference_steps=2   ,				output_type='''np'''   ,				).images

       UpperCamelCase__										=      low_res_image.size[0] * 4
       assert image.shape == (1, expected_height_width, expected_height_width, 3)



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






  def 		_a					(self	)		->      Union[str, Any]:





       '''simple docstring'''





       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()






  def 		_a					(self	)		->      str:





       '''simple docstring'''





       UpperCamelCase__										=      load_image(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/sd2-upscale/low_res_cat.png'''	)
       UpperCamelCase__										=      load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'''
           '''/upsampled_cat.npy'''	)

       UpperCamelCase__										=      '''stabilityai/stable-diffusion-x4-upscaler'''
       UpperCamelCase__										=      StableDiffusionUpscalePipeline.from_pretrained(SCREAMING_SNAKE_CASE_	)
       pipe.to(SCREAMING_SNAKE_CASE_	)
       pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)
       pipe.enable_attention_slicing()

       UpperCamelCase__										=      '''a cat sitting on a park bench'''

       UpperCamelCase__										=      torch.manual_seed(0	)
       UpperCamelCase__										=      pipe(
           prompt=SCREAMING_SNAKE_CASE_   ,				image=SCREAMING_SNAKE_CASE_   ,				generator=SCREAMING_SNAKE_CASE_   ,				output_type='''np'''   ,				)
       UpperCamelCase__										=      output.images[0]

       assert image.shape == (512, 512, 3)
       assert np.abs(expected_image - image	).max() < 1E-3






  def 		_a					(self	)		->      Tuple:





       '''simple docstring'''





       UpperCamelCase__										=      load_image(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/sd2-upscale/low_res_cat.png'''	)
       UpperCamelCase__										=      load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'''
           '''/upsampled_cat_fp16.npy'''	)

       UpperCamelCase__										=      '''stabilityai/stable-diffusion-x4-upscaler'''
       UpperCamelCase__										=      StableDiffusionUpscalePipeline.from_pretrained(
           SCREAMING_SNAKE_CASE_   ,				torch_dtype=torch.floataa   ,				)
       pipe.to(SCREAMING_SNAKE_CASE_	)
       pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)
       pipe.enable_attention_slicing()

       UpperCamelCase__										=      '''a cat sitting on a park bench'''

       UpperCamelCase__										=      torch.manual_seed(0	)
       UpperCamelCase__										=      pipe(
           prompt=SCREAMING_SNAKE_CASE_   ,				image=SCREAMING_SNAKE_CASE_   ,				generator=SCREAMING_SNAKE_CASE_   ,				output_type='''np'''   ,				)
       UpperCamelCase__										=      output.images[0]

       assert image.shape == (512, 512, 3)
       assert np.abs(expected_image - image	).max() < 5E-1






  def 		_a					(self	)		->      Union[str, Any]:





       '''simple docstring'''





       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()

       UpperCamelCase__										=      load_image(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/sd2-upscale/low_res_cat.png'''	)

       UpperCamelCase__										=      '''stabilityai/stable-diffusion-x4-upscaler'''
       UpperCamelCase__										=      StableDiffusionUpscalePipeline.from_pretrained(
           SCREAMING_SNAKE_CASE_   ,				torch_dtype=torch.floataa   ,				)
       pipe.to(SCREAMING_SNAKE_CASE_	)
       pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)
       pipe.enable_attention_slicing(1	)
       pipe.enable_sequential_cpu_offload()

       UpperCamelCase__										=      '''a cat sitting on a park bench'''

       UpperCamelCase__										=      torch.manual_seed(0	)
       UpperCamelCase__										=      pipe(
           prompt=SCREAMING_SNAKE_CASE_   ,				image=SCREAMING_SNAKE_CASE_   ,				generator=SCREAMING_SNAKE_CASE_   ,				num_inference_steps=5   ,				output_type='''np'''   ,				)

       UpperCamelCase__										=      torch.cuda.max_memory_allocated()
       # make sure that less than 2.9 GB is allocated
       assert mem_bytes < 2.9 * 10**9




from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase







def  __UpperCamelCase    (						A							):
     UpperCamelCase__						,       UpperCamelCase__										=      analyze_text(A							)
     UpperCamelCase__										=      list(''' ''' + ascii_lowercase							)
     # what is our total sum of probabilities.
     UpperCamelCase__										=      sum(single_char_strings.values()							)

     # one length string
     UpperCamelCase__										=      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:
               UpperCamelCase__										=      single_char_strings[ch]
               UpperCamelCase__										=      my_str / all_sum
               my_fir_sum += prob * math.loga(A							)  # entropy formula.

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

     # two len string
     UpperCamelCase__										=      sum(two_char_strings.values()							)
     UpperCamelCase__										=      0
     # for each alpha (two in size) calculate entropy.
     for cha in my_alphas:
          for cha in my_alphas:
               UpperCamelCase__										=      cha + cha
               if sequence in two_char_strings:
                    UpperCamelCase__										=      two_char_strings[sequence]
                    UpperCamelCase__										=      int(A							) / all_sum
                    my_sec_sum += prob * math.loga(A							)

    # 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  __UpperCamelCase    (						A							):
     UpperCamelCase__										=      Counter()  # type: ignore
     UpperCamelCase__										=      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(A							) - 1							):
          single_char_strings[text[i]] += 1
          two_char_strings[text[i : i + 2]] += 1
     return single_char_strings, two_char_strings







def  __UpperCamelCase    (						):
     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()



