






"""simple docstring"""







from logging import getLogger
from typing import Any, Callable, List, Optional, Union

import numpy as np
import PIL
import torch

from ...schedulers import DDPMScheduler
from ..onnx_utils import ORT_TO_NP_TYPE, OnnxRuntimeModel
from ..pipeline_utils import ImagePipelineOutput
from . import StableDiffusionUpscalePipeline


_UpperCamelCase     			=  getLogger(__name__)


_UpperCamelCase     			=  4
_UpperCamelCase     			=  7

_UpperCamelCase     			=  {
    """float16""": torch.floataa,
    """float32""": torch.floataa,
}

def _a (		_snake_case							):







      """simple docstring"""






      if isinstance(_snake_case      ,       torch.Tensor							):
            return image
      elif isinstance(_snake_case      ,       PIL.Image.Image							):
            UpperCAmelCase							=       [image]

      if isinstance(image[0]      ,       PIL.Image.Image							):
            UpperCAmelCase			,					UpperCAmelCase							=       image[0].size
            UpperCAmelCase			,					UpperCAmelCase							=       (x - x % 64 for x in (w, h))  # resize to integer multiple of 32

            UpperCAmelCase							=       [np.array(i.resize((w, h)							)							)[None, :] for i in image]
            UpperCAmelCase							=       np.concatenate(_snake_case      ,       axis=0							)
            UpperCAmelCase							=       np.array(_snake_case							).astype(np.floataa							) / 255.0
            UpperCAmelCase							=       image.transpose(0      ,       3      ,       1      ,       2							)
            UpperCAmelCase							=       2.0 * image - 1.0
            UpperCAmelCase							=       torch.from_numpy(_snake_case							)
      elif isinstance(image[0]      ,       torch.Tensor							):
            UpperCAmelCase							=       torch.cat(_snake_case      ,       dim=0							)

      return image







class 					lowerCamelCase__					(       snake_case ):






    def __init__( self	,A	,A	,A	,A	,A	,A	,A = 350	,):
          super().__init__(
              vae=A	,text_encoder=A	,tokenizer=A	,unet=A	,low_res_scheduler=A	,scheduler=A	,safety_checker=A	,feature_extractor=A	,watermarker=A	,max_noise_level=A	,)






    def __call__( self	,A	,A	,A = 75	,A = 9.0	,A = 20	,A = None	,A = 1	,A = 0.0	,A = None	,A = None	,A = None	,A = None	,A = "pil"	,A = True	,A = None	,A = 1	,):
          self.check_inputs(A	,A	,A	,A					)

          # 2. Define call parameters
          if prompt is not None and isinstance(A	,A					):
                UpperCAmelCase							=       1
          elif prompt is not None and isinstance(A	,A					):
                UpperCAmelCase							=       len(A					)
          else:
                UpperCAmelCase							=       prompt_embeds.shape[0]

          UpperCAmelCase							=       self._execution_device
          # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
          # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
          # corresponds to doing no classifier free guidance.
          UpperCAmelCase							=       guidance_scale > 1.0

          # 3. Encode input prompt
          UpperCAmelCase							=       self._encode_prompt(
              A	,A	,A	,A	,A	,prompt_embeds=A	,negative_prompt_embeds=A	,)

          UpperCAmelCase							=       ORT_TO_PT_TYPE[str(text_embeddings.dtype					)]

          # 4. Preprocess image
          UpperCAmelCase							=       preprocess(A					)
          UpperCAmelCase							=       image.cpu()

          # 5. set timesteps
          self.scheduler.set_timesteps(A	,device=A					)
          UpperCAmelCase							=       self.scheduler.timesteps

          # 5. Add noise to image
          UpperCAmelCase							=       torch.tensor([noise_level]	,dtype=torch.long	,device=A					)
          UpperCAmelCase							=       torch.randn(image.shape	,generator=A	,device=A	,dtype=A					)
          UpperCAmelCase							=       self.low_res_scheduler.add_noise(A	,A	,A					)

          UpperCAmelCase							=       2 if do_classifier_free_guidance else 1
          UpperCAmelCase							=       np.concatenate([image] * batch_multiplier * num_images_per_prompt					)
          UpperCAmelCase							=       np.concatenate([noise_level] * image.shape[0]					)

          # 6. Prepare latent variables
          UpperCAmelCase			,					UpperCAmelCase							=       image.shape[2:]
          UpperCAmelCase							=       self.prepare_latents(
              batch_size * num_images_per_prompt	,A	,A	,A	,A	,A	,A	,A	,)

          # 7. Check that sizes of image and latents match
          UpperCAmelCase							=       image.shape[1]
          if NUM_LATENT_CHANNELS + num_channels_image != NUM_UNET_INPUT_CHANNELS:
                raise ValueError(
                    """Incorrect configuration settings! The config of `pipeline.unet` expects"""
                    F''' {NUM_UNET_INPUT_CHANNELS} but received `num_channels_latents`: {NUM_LATENT_CHANNELS} +'''
                    F''' `num_channels_image`: {num_channels_image} '''
                    F''' = {NUM_LATENT_CHANNELS+num_channels_image}. Please verify the config of'''
                    """ `pipeline.unet` or your `image` input."""					)

          # 8. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
          UpperCAmelCase							=       self.prepare_extra_step_kwargs(A	,A					)

          UpperCAmelCase							=       next(
              (input.type for input in self.unet.model.get_inputs() if input.name == """timestep""")	,"""tensor(float)"""					)
          UpperCAmelCase							=       ORT_TO_NP_TYPE[timestep_dtype]

          # 9. Denoising loop
          UpperCAmelCase							=       len(A					) - num_inference_steps * self.scheduler.order
          with self.progress_bar(total=A					) as progress_bar:
                for i, t in enumerate(A					):
                      # expand the latents if we are doing classifier free guidance
                      UpperCAmelCase							=       np.concatenate([latents] * 2					) if do_classifier_free_guidance else latents

                      # concat latents, mask, masked_image_latents in the channel dimension
                      UpperCAmelCase							=       self.scheduler.scale_model_input(A	,A					)
                      UpperCAmelCase							=       np.concatenate([latent_model_input, image]	,axis=1					)

                      # timestep to tensor
                      UpperCAmelCase							=       np.array([t]	,dtype=A					)

                      # predict the noise residual
                      UpperCAmelCase							=       self.unet(
                          sample=A	,timestep=A	,encoder_hidden_states=A	,class_labels=noise_level.astype(np.intaa					)	,)[0]

                      # perform guidance
                      if do_classifier_free_guidance:
                            UpperCAmelCase			,					UpperCAmelCase							=       np.split(A	,2					)
                      UpperCAmelCase							=       noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

                      # compute the previous noisy sample x_t -> x_t-1
                      UpperCAmelCase							=       self.scheduler.step(
                          torch.from_numpy(A					)	,A	,A	,**A					).prev_sample

                      # call the callback, if provided
                      if i == len(A					) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
                            progress_bar.update()
                            if callback is not None and i % callback_steps == 0:
                                  callback(A	,A	,A					)

        # 10. Post-processing
          UpperCAmelCase							=       self.decode_latents(latents.float()					)

          # 11. Convert to PIL
          if output_type == "pil":
                UpperCAmelCase							=       self.numpy_to_pil(A					)

          if not return_dict:
                return (image,)

          return ImagePipelineOutput(images=A					)






    def 				_UpperCamelCase							( self	,A					):
          UpperCAmelCase							=       1 / 0.08333 * latents
          UpperCAmelCase							=       self.vae(latent_sample=A					)[0]
          UpperCAmelCase							=       np.clip(image / 2 + 0.5	,0	,1					)
          UpperCAmelCase							=       image.transpose((0, 2, 3, 1)					)
          return image






    def 				_UpperCamelCase							( self	,A	,A	,A	,A	,A	,A = None	,A = None	,):
          if prompt is not None and isinstance(A	,A					):
                UpperCAmelCase							=       1
          elif prompt is not None and isinstance(A	,A					):
                UpperCAmelCase							=       len(A					)
          else:
                UpperCAmelCase							=       prompt_embeds.shape[0]

          if prompt_embeds is None:
                UpperCAmelCase							=       self.tokenizer(
                    A	,padding="""max_length"""	,max_length=self.tokenizer.model_max_length	,truncation=A	,return_tensors="""pt"""	,)
                UpperCAmelCase							=       text_inputs.input_ids
                UpperCAmelCase							=       self.tokenizer(A	,padding="""longest"""	,return_tensors="""pt"""					).input_ids

                if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
                    A	,A					):
                      UpperCAmelCase							=       self.tokenizer.batch_decode(
                          untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]					)
                      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}'''					)

                # no positional arguments to text_encoder
                UpperCAmelCase							=       self.text_encoder(
                    input_ids=text_input_ids.int().to(A					)	,)
                UpperCAmelCase							=       prompt_embeds[0]

          UpperCAmelCase			,					UpperCAmelCase			,					UpperCAmelCase							=       prompt_embeds.shape
          # duplicate text embeddings for each generation per prompt, using mps friendly method
          UpperCAmelCase							=       prompt_embeds.repeat(1	,A					)
          UpperCAmelCase							=       prompt_embeds.reshape(bs_embed * num_images_per_prompt	,A	,-1					)

          # get unconditional embeddings for classifier free guidance
          if do_classifier_free_guidance and negative_prompt_embeds is None:
                UpperCAmelCase							=       42
                if negative_prompt is None:
                      UpperCAmelCase							=       [""""""] * batch_size
                elif type(A					) is not type(A					):
                      raise TypeError(
                          F'''`negative_prompt` should be the same type to `prompt`, but got {type(A					)} !='''
                          F''' {type(A					)}.'''					)
                elif isinstance(A	,A					):
                      UpperCAmelCase							=       [negative_prompt]
                elif batch_size != len(A					):
                      raise ValueError(
                          F'''`negative_prompt`: {negative_prompt} has batch size {len(A					)}, but `prompt`:'''
                          F''' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'''
                          """ the batch size of `prompt`."""					)
                else:
                      UpperCAmelCase							=       negative_prompt

                UpperCAmelCase							=       text_input_ids.shape[-1]
                UpperCAmelCase							=       self.tokenizer(
                    A	,padding="""max_length"""	,max_length=A	,truncation=A	,return_tensors="""pt"""	,)

                # if hasattr(uncond_input, "attention_mask"):
                #     attention_mask = uncond_input.attention_mask.to(device)
                # else:
                #     attention_mask = None

                UpperCAmelCase							=       self.text_encoder(
                    input_ids=uncond_input.input_ids.int().to(A					)	,)
                UpperCAmelCase							=       uncond_embeddings[0]

          if do_classifier_free_guidance:
                UpperCAmelCase							=       uncond_embeddings.shape[1]
                # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
                UpperCAmelCase							=       uncond_embeddings.repeat(1	,A					)
                UpperCAmelCase							=       uncond_embeddings.reshape(batch_size * num_images_per_prompt	,A	,-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							=       np.concatenate([uncond_embeddings, prompt_embeds]					)

          return prompt_embeds











"""simple docstring"""







from collections import Counter
import datasets
import transformers
from transformers.convert_slow_tokenizer import SLOW_TO_FAST_CONVERTERS

from transformers.utils import logging

logging.set_verbosity_info()

_UpperCamelCase     			=  {
    name: (getattr(transformers, name), getattr(transformers, name + """Fast""")) for name in SLOW_TO_FAST_CONVERTERS
}

_UpperCamelCase     			=  datasets.load_dataset("""xnli""", split="""test+validation""")

_UpperCamelCase     			=  0
_UpperCamelCase     			=  0
_UpperCamelCase     			=  0
_UpperCamelCase     			=  0

def _a (		_snake_case      ,       _snake_case      ,       _snake_case      ,       _snake_case							):







      """simple docstring"""






      if spm_diff == list(reversed(_snake_case							)							):
            # AAA -> AA+A vs A+AA case.
            return True
      elif len(_snake_case							) == len(_snake_case							) and fast.decode(_snake_case							) == fast.decode(_snake_case							):
            # Second order OK
            # Barrich -> Barr + ich vs Bar + rich
            return True
      UpperCAmelCase							=       slow.encode(slow.decode(_snake_case							)							)
      UpperCAmelCase							=       fast.encode(fast.decode(_snake_case							)							)
      if spm_reencoded != spm_diff and spm_reencoded == tok_reencoded:
            # Type 3 error.
            # Snehagatha ->
            #       Sne, h, aga, th, a
            #       Sne, ha, gat, ha
            # Encoding the wrong with sp does not even recover what spm gave us
            # It fits tokenizer however...
            return True
      return False

def _a (		_snake_case      ,       _snake_case      ,       _snake_case							):







      """simple docstring"""






      UpperCAmelCase							=       fast.encode_plus(_snake_case							)[0]
      UpperCAmelCase							=       enc.offsets
      UpperCAmelCase			,					UpperCAmelCase							=       offsets[idx], offsets[idx - 1]
      if curr is not None and line[curr[0] : curr[1]] == "\u200f":
            return True
      if prev is not None and line[prev[0] : prev[1]] == "\u200f":
            return True

def _a (		_snake_case      ,       _snake_case      ,       _snake_case      ,       _snake_case      ,       _snake_case							):







      """simple docstring"""






      for i, (spm_id, tok_id) in enumerate(zip(_snake_case      ,       _snake_case							)							):
            if spm_id != tok_id:
                  break
      UpperCAmelCase							=       i
      for i, (spm_id, tok_id) in enumerate(zip(reversed(_snake_case							)      ,       reversed(_snake_case							)							)							):
            if spm_id != tok_id:
                  break
      UpperCAmelCase							=       len(_snake_case							) - i

      UpperCAmelCase							=       spm_ids[first:last]
      UpperCAmelCase							=       tok_ids[first:last]

      if check_diff(_snake_case      ,       _snake_case      ,       _snake_case      ,       _snake_case							):
            return True

      if check_LTR_mark(_snake_case      ,       _snake_case      ,       _snake_case							):
            return True

      if last - first > 5:
            # We might have twice a single problem, attempt to subdivide the disjointed tokens into smaller problems
            UpperCAmelCase							=       Counter(spm_ids[first:last]							)
            UpperCAmelCase							=       Counter(tok_ids[first:last]							)

            UpperCAmelCase							=       {spm_ for (spm_, si) in spms.items() if toks.get(spm_      ,       0							) == si}
            UpperCAmelCase							=       3
            for i in range(last - first - min_width							):
                  if all(spm_ids[first + i + j] in removable_tokens for j in range(_snake_case							)							):
                        UpperCAmelCase							=       [
                            k
                            for k in range(last - first - min_width							)
                            if tok_ids[first + k : first + k + min_width] == spm_ids[first + i : first + i + min_width]
                        ]
                        for j in possible_matches:
                              if check_diff(spm_ids[first : first + i]      ,       tok_ids[first : first + j]      ,       _snake_case      ,       _snake_case							) and check_details(
                                  _snake_case      ,       spm_ids[first + i : last]      ,       tok_ids[first + j : last]      ,       _snake_case      ,       _snake_case      ,       ):
                                    return True

      print(F'''Spm: {[fast.decode([spm_ids[i]]							) for i in range(_snake_case      ,       _snake_case							)]}'''							)
      try:
            print(F'''Tok: {[fast.decode([tok_ids[i]]							) for i in range(_snake_case      ,       _snake_case							)]}'''							)
      except Exception:
            pass

      UpperCAmelCase							=       fast.decode(spm_ids[:first]							)
      UpperCAmelCase							=       fast.decode(spm_ids[last:]							)
      UpperCAmelCase							=       fast.decode(spm_ids[first:last]							)
      print()
      print(_snake_case							)
      return False

def _a (		_snake_case      ,       _snake_case      ,       _snake_case							):







      """simple docstring"""






      global perfect
      global imperfect
      global wrong
      global total

      UpperCAmelCase							=       slow.encode(_snake_case							)
      UpperCAmelCase							=       fast.encode(_snake_case							)

      UpperCAmelCase							=       False
      total += 1

      if slow_ids != fast_ids:
            if check_details(_snake_case      ,       _snake_case      ,       _snake_case      ,       _snake_case      ,       _snake_case							):
                  UpperCAmelCase							=       True
                  imperfect += 1
            else:
                  wrong += 1
      else:
            perfect += 1

      if total % 1_0000 == 0:
            print(F'''({perfect} / {imperfect} / {wrong} ----- {perfect + imperfect + wrong})'''							)

      if skip_assert:
            return

      assert (
          slow_ids == fast_ids
      ), F'''line {text} : \n\n{slow_ids}\n{fast_ids}\n\n{slow.tokenize(_snake_case							)}\n{fast.tokenize(_snake_case							)}'''

def _a (		_snake_case      ,       _snake_case							):







      """simple docstring"""






      global batch_total
      for i in range(len(_snake_case							)							):
            # premise, all languages
            for text in dataset[i]["premise"].values():
                  test_string(_snake_case      ,       _snake_case      ,       _snake_case							)

            # hypothesis, all languages
            for text in dataset[i]["hypothesis"]["translation"]:
                  test_string(_snake_case      ,       _snake_case      ,       _snake_case							)


if __name__ == "__main__":
  for name, (slow_class, fast_class) in TOKENIZER_CLASSES.items():
    _UpperCamelCase     			=  list(slow_class.max_model_input_sizes.keys())
    for checkpoint in checkpoint_names:
      _UpperCamelCase     			=  0
      _UpperCamelCase     			=  0
      _UpperCamelCase     			=  0
      _UpperCamelCase     			=  0

      print(F"""========================== Checking {name}: {checkpoint} ==========================""")
      _UpperCamelCase     			=  slow_class.from_pretrained(checkpoint, force_download=True)
      _UpperCamelCase     			=  fast_class.from_pretrained(checkpoint, force_download=True)
      test_tokenizer(slow, fast)
      print(F"""Accuracy {perfect * 100 / total:.2f}""")



