
"""simple docstring"""

from typing import Callable, List, Optional, Tuple, Union

import torch
from transformers import CLIPTextModel, CLIPTokenizer

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin, TransformeraDModel, VQModel
from ...schedulers import VQDiffusionScheduler
from ...utils import logging
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput


SCREAMING_SNAKE_CASE_            =    logging.get_logger(__name__)  # pylint: disable=invalid-name
class   _UpperCAmelCase				(		SCREAMING_SNAKE_CASE_  ,      SCREAMING_SNAKE_CASE_				):




      @register_to_config
      def __init__(				self ,							lowercase_ ,							lowercase_ = None ,							lowercase_ = None				)    ->       Optional[Any]:
          super().__init__()

          UpperCAmelCase          =       learnable

          if self.learnable:
              assert hidden_size is not None, "learnable=True requires `hidden_size` to be set"
              assert length is not None, "learnable=True requires `length` to be set"

              UpperCAmelCase          =       torch.zeros(lowercase_ ,							lowercase_				)
          else:
              UpperCAmelCase          =       None

          UpperCAmelCase          =       torch.nn.Parameter(lowercase_				)

class   _UpperCAmelCase				(		SCREAMING_SNAKE_CASE_				):
      __SCREAMING_SNAKE_CASE :				VQModel
      __SCREAMING_SNAKE_CASE :				CLIPTextModel
      __SCREAMING_SNAKE_CASE :				CLIPTokenizer
      __SCREAMING_SNAKE_CASE :				TransformeraDModel
      __SCREAMING_SNAKE_CASE :				LearnedClassifierFreeSamplingEmbeddings
      __SCREAMING_SNAKE_CASE :				VQDiffusionScheduler




      def __init__(				self ,							lowercase_ ,							lowercase_ ,							lowercase_ ,							lowercase_ ,							lowercase_ ,							lowercase_ ,							)    ->       List[str]:
          super().__init__()

          self.register_modules(
              vqvae=lowercase_ ,							transformer=lowercase_ ,							text_encoder=lowercase_ ,							tokenizer=lowercase_ ,							scheduler=lowercase_ ,							learned_classifier_free_sampling_embeddings=lowercase_ ,							)




      def      a_   (				self ,							lowercase_ ,							lowercase_ ,							lowercase_				)    ->       Tuple:
          UpperCAmelCase          =       len(lowercase_				) if isinstance(lowercase_ ,							lowercase_				) else 1

          # get prompt text embeddings
          UpperCAmelCase          =       self.tokenizer(
              lowercase_ ,							padding='max_length' ,							max_length=self.tokenizer.model_max_length ,							return_tensors='pt' ,							)
          UpperCAmelCase          =       text_inputs.input_ids

          if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
              UpperCAmelCase          =       self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]				)
              logger.warning(
                  'The following part of your input was truncated because CLIP can only handle sequences up to'
                  F" {self.tokenizer.model_max_length} tokens: {removed_text}"				)
              UpperCAmelCase          =       text_input_ids[:, : self.tokenizer.model_max_length]
          UpperCAmelCase          =       self.text_encoder(text_input_ids.to(self.device				)				)[0]

          # NOTE: This additional step of normalizing the text embeddings is from VQ-Diffusion.
          # While CLIP does normalize the pooled output of the text transformer when combining
          # the image and text embeddings, CLIP does not directly normalize the last hidden state.
          #
          # CLIP normalizing the pooled output.
          # https://github.com/huggingface/transformers/blob/d92e22d1f28324f513f3080e5c47c071a3916721/src/transformers/models/clip/modeling_clip.py#L1052-L1053
          UpperCAmelCase          =       prompt_embeds / prompt_embeds.norm(dim=-1 ,							keepdim=lowercase_				)

          # duplicate text embeddings for each generation per prompt
          UpperCAmelCase          =       prompt_embeds.repeat_interleave(lowercase_ ,							dim=0				)

          if do_classifier_free_guidance:
              if self.learned_classifier_free_sampling_embeddings.learnable:
                  UpperCAmelCase          =       self.learned_classifier_free_sampling_embeddings.embeddings
                  UpperCAmelCase          =       negative_prompt_embeds.unsqueeze(0				).repeat(lowercase_ ,							1 ,							1				)
              else:
                  UpperCAmelCase          =       [''] * batch_size

                  UpperCAmelCase          =       text_input_ids.shape[-1]
                  UpperCAmelCase          =       self.tokenizer(
                      lowercase_ ,							padding='max_length' ,							max_length=lowercase_ ,							truncation=lowercase_ ,							return_tensors='pt' ,							)
                  UpperCAmelCase          =       self.text_encoder(uncond_input.input_ids.to(self.device				)				)[0]
                  # See comment for normalizing text embeddings
                  UpperCAmelCase          =       negative_prompt_embeds / negative_prompt_embeds.norm(dim=-1 ,							keepdim=lowercase_				)

              # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
              UpperCAmelCase          =       negative_prompt_embeds.shape[1]
              UpperCAmelCase          =       negative_prompt_embeds.repeat(1 ,							lowercase_ ,							1				)
              UpperCAmelCase          =       negative_prompt_embeds.view(batch_size * num_images_per_prompt ,							lowercase_ ,							-1				)

              # For classifier free guidance, we need to do two forward passes.
              # Here we concatenate the unconditional and text embeddings into a single batch
              # to avoid doing two forward passes
              UpperCAmelCase          =       torch.cat([negative_prompt_embeds, prompt_embeds]				)

          return prompt_embeds




      @torch.no_grad()
      def __call__(				self ,							lowercase_ ,							lowercase_ = 1_0_0 ,							lowercase_ = 5.0 ,							lowercase_ = 1.0 ,							lowercase_ = 1 ,							lowercase_ = None ,							lowercase_ = None ,							lowercase_ = "pil" ,							lowercase_ = True ,							lowercase_ = None ,							lowercase_ = 1 ,							)    ->       Union[ImagePipelineOutput, Tuple]:
          if isinstance(lowercase_ ,							lowercase_				):
              UpperCAmelCase          =       1
          elif isinstance(lowercase_ ,							lowercase_				):
              UpperCAmelCase          =       len(lowercase_				)
          else:
              raise ValueError(F"`prompt` has to be of type `str` or `list` but is {type(lowercase_				)}"				)

          UpperCAmelCase          =       batch_size * num_images_per_prompt

          UpperCAmelCase          =       guidance_scale > 1.0

          UpperCAmelCase          =       self._encode_prompt(lowercase_ ,							lowercase_ ,							lowercase_				)

          if (callback_steps is None) or (
              callback_steps is not None and (not isinstance(lowercase_ ,							lowercase_				) or callback_steps <= 0)
          ):
              raise ValueError(
                  F"`callback_steps` has to be a positive integer but is {callback_steps} of type"
                  F" {type(lowercase_				)}."				)

          # get the initial completely masked latents unless the user supplied it

          UpperCAmelCase          =       (batch_size, self.transformer.num_latent_pixels)
          if latents is None:
              UpperCAmelCase          =       self.transformer.num_vector_embeds - 1
              UpperCAmelCase          =       torch.full(lowercase_ ,							lowercase_				).to(self.device				)
          else:
              if latents.shape != latents_shape:
                  raise ValueError(F"Unexpected latents shape, got {latents.shape}, expected {latents_shape}"				)
              if (latents < 0).any() or (latents >= self.transformer.num_vector_embeds).any():
                  raise ValueError(
                      'Unexpected latents value(s). All latents be valid embedding indices i.e. in the range 0,'
                      F" {self.transformer.num_vector_embeds - 1} (inclusive)."				)
              UpperCAmelCase          =       latents.to(self.device				)

          # set timesteps
          self.scheduler.set_timesteps(lowercase_ ,							device=self.device				)

          UpperCAmelCase          =       self.scheduler.timesteps.to(self.device				)

          UpperCAmelCase          =       latents

          for i, t in enumerate(self.progress_bar(lowercase_				)				):
              # expand the sample if we are doing classifier free guidance
              UpperCAmelCase          =       torch.cat([sample] * 2				) if do_classifier_free_guidance else sample

              # predict the un-noised image
              # model_output == `log_p_x_0`
              UpperCAmelCase          =       self.transformer(lowercase_ ,							encoder_hidden_states=lowercase_ ,							timestep=lowercase_				).sample

              if do_classifier_free_guidance:
                  UpperCAmelCase      ,				UpperCAmelCase          =       model_output.chunk(2				)
                  UpperCAmelCase          =       model_output_uncond + guidance_scale * (model_output_text - model_output_uncond)
                  model_output -= torch.logsumexp(lowercase_ ,							dim=1 ,							keepdim=lowercase_				)

              UpperCAmelCase          =       self.truncate(lowercase_ ,							lowercase_				)

              # remove `log(0)`'s (`-inf`s)
              UpperCAmelCase          =       model_output.clamp(-7_0				)

              # compute the previous noisy sample x_t -> x_t-1
              UpperCAmelCase          =       self.scheduler.step(lowercase_ ,							timestep=lowercase_ ,							sample=lowercase_ ,							generator=lowercase_				).prev_sample

              # call the callback, if provided
              if callback is not None and i % callback_steps == 0:
                  callback(lowercase_ ,							lowercase_ ,							lowercase_				)

          UpperCAmelCase          =       self.vqvae.config.vq_embed_dim
          UpperCAmelCase          =       (batch_size, self.transformer.height, self.transformer.width, embedding_channels)
          UpperCAmelCase          =       self.vqvae.quantize.get_codebook_entry(lowercase_ ,							shape=lowercase_				)
          UpperCAmelCase          =       self.vqvae.decode(lowercase_ ,							force_not_quantize=lowercase_				).sample

          UpperCAmelCase          =       (image / 2 + 0.5).clamp(0 ,							1				)
          UpperCAmelCase          =       image.cpu().permute(0 ,							2 ,							3 ,							1				).numpy()

          if output_type == "pil":
              UpperCAmelCase          =       self.numpy_to_pil(lowercase_				)

          if not return_dict:
              return (image,)

          return ImagePipelineOutput(images=lowercase_				)




      def      a_   (				self ,							lowercase_ ,							lowercase_				)    ->       torch.FloatTensor:
          UpperCAmelCase      ,				UpperCAmelCase          =       torch.sort(lowercase_ ,							1 ,							descending=lowercase_				)
          UpperCAmelCase          =       torch.exp(lowercase_				)
          UpperCAmelCase          =       sorted_p_x_0.cumsum(dim=1				) < truncation_rate

          # Ensure that at least the largest probability is not zeroed out
          UpperCAmelCase          =       torch.full_like(keep_mask[:, 0:1, :] ,							lowercase_				)
          UpperCAmelCase          =       torch.cat((all_true, keep_mask) ,							dim=1				)
          UpperCAmelCase          =       keep_mask[:, :-1, :]

          UpperCAmelCase          =       keep_mask.gather(1 ,							indices.argsort(1				)				)

          UpperCAmelCase          =       log_p_x_0.clone()

          UpperCAmelCase          =       -torch.inf  # -inf = log(0)

          return rv





"""simple docstring"""

import math




def      lowercase__    (       lowerCAmelCase					:       str			,					lowerCAmelCase					:       Optional[Any]			)			->   List[Any]:






    """simple docstring"""




    if 0 not in (x, y):
        # We use the relation x^y = y*log10(x), where 10 is the base.
        return y * math.logaa(lowerCAmelCase			)
    else:
        if x == 0:  # 0 raised to any number is 0
            return 0
        elif y == 0:
            return 1  # any number raised to 0 is 1
    raise AssertionError('This should never happen'			)


if __name__ == "__main__":  # Main function
   # Read two numbers from input and typecast them to int using map function.
   # Here x is the base and y is the power.
   SCREAMING_SNAKE_CASE_            =    '''Enter the base and the power separated by a comma: '''
   SCREAMING_SNAKE_CASE_       ,    SCREAMING_SNAKE_CASE_            =    map(int, input(prompt).split(''','''))
   SCREAMING_SNAKE_CASE_       ,    SCREAMING_SNAKE_CASE_            =    map(int, input(prompt).split(''','''))

   # We find the log of each number, using the function res(), which takes two
   # arguments.
   SCREAMING_SNAKE_CASE_            =    res(xa, ya)
   SCREAMING_SNAKE_CASE_            =    res(xa, ya)

   # We check for the largest number
   if resa > resa:
      print('''Largest number is''', xa, '''^''', ya)
   elif resa > resa:
      print('''Largest number is''', xa, '''^''', ya)
   else:
      print('''Both are equal''')



