






'''simple docstring'''



from ...configuration_utils import PretrainedConfig
from ...utils import logging


__UpperCamelCase      :       Any      			=      logging.get_logger(__name__)

__UpperCamelCase      :       List[Any]      			=      {
    "tiiuae/falcon-40b": "https://huggingface.co/tiiuae/falcon-40b/resolve/main/config.json",
    "tiiuae/falcon-7b": "https://huggingface.co/tiiuae/falcon-7b/resolve/main/config.json",
}
class 							__SCREAMING_SNAKE_CASE       (							_UpperCAmelCase     ):
      __a  					="falcon"
      __a  					=["past_key_values"]




      def __init__(  self ,   lowerCamelCase=6_5024 ,   lowerCamelCase=4544 ,   lowerCamelCase=32 ,   lowerCamelCase=71 ,   lowerCamelCase=1e-5 ,   lowerCamelCase=0.02 ,   lowerCamelCase=True ,   lowerCamelCase=0.0 ,   lowerCamelCase=0.0 ,   lowerCamelCase=None ,   lowerCamelCase=False ,   lowerCamelCase=False ,   lowerCamelCase=True ,   lowerCamelCase=True ,   lowerCamelCase=False ,   lowerCamelCase=11 ,   lowerCamelCase=11 ,   **lowerCamelCase ,   )							->Any:



         '''simple docstring'''
         __a				     =    vocab_size
         # Backward compatibility with n_embed kwarg
         __a				     =    kwargs.pop('n_embed' ,   lowerCamelCase_      )
         __a				     =    hidden_size if n_embed is None else n_embed
         __a				     =    num_hidden_layers
         __a				     =    num_attention_heads
         __a				     =    layer_norm_epsilon
         __a				     =    initializer_range
         __a				     =    use_cache
         __a				     =    hidden_dropout
         __a				     =    attention_dropout

         __a				     =    bos_token_id
         __a				     =    eos_token_id
         __a				     =    num_attention_heads if num_kv_heads is None else num_kv_heads
         __a				     =    alibi
         __a				     =    new_decoder_architecture
         __a				     =    multi_query  # Ignored when new_decoder_architecture is True
         __a				     =    parallel_attn
         __a				     =    bias

         super().__init__(bos_token_id=lowerCamelCase_ ,   eos_token_id=lowerCamelCase_ ,   **lowerCamelCase_      )




      @property
      def  __UpperCamelCase							(  self      )							->Dict:



         '''simple docstring'''
         return self.hidden_size // self.num_attention_heads






      @property
      def  __UpperCamelCase							(  self      )							->Any:



         '''simple docstring'''
         return not self.alibi







'''simple docstring'''



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

import numpy as np
import PIL
import torch
import torch.utils.checkpoint

from ...models import UNetaDModel, VQModel
from ...schedulers import (
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
)
from ...utils import PIL_INTERPOLATION, randn_tensor
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	List[Any]    )  ->			Dict:

   """simple docstring"""
   __a     ,			__a				     =    image.size
   __a     ,			__a				     =    (x - x % 32 for x in (w, h))  # resize to integer multiple of 32
   __a				     =    image.resize((w, h),					resample=PIL_INTERPOLATION['lanczos']    )
   __a				     =    np.array(SCREAMING_SNAKE_CASE__    ).astype(np.floataa    ) / 2_5_5.0
   __a				     =    image[None].transpose(0,					3,					1,					2    )
   __a				     =    torch.from_numpy(SCREAMING_SNAKE_CASE__    )
   return 2.0 * image - 1.0



class 							__SCREAMING_SNAKE_CASE       (							_lowerCAmelCase     ):




      def __init__(  self ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   )							->Dict:



         '''simple docstring'''
         super().__init__()
         self.register_modules(vqvae=lowerCamelCase ,   unet=lowerCamelCase ,   scheduler=lowerCamelCase      )






      @torch.no_grad()
      def __call__(  self ,   lowerCamelCase = None ,   lowerCamelCase = 1 ,   lowerCamelCase = 100 ,   lowerCamelCase = 0.0 ,   lowerCamelCase = None ,   lowerCamelCase = "pil" ,   lowerCamelCase = True ,   )							->Union[Tuple, ImagePipelineOutput]:



         '''simple docstring'''
         if isinstance(lowerCamelCase ,   PIL.Image.Image      ):
            __a				     =    1
         elif isinstance(lowerCamelCase ,   torch.Tensor      ):
            __a				     =    image.shape[0]
         else:
            raise ValueError(F"""`image` has to be of type `PIL.Image.Image` or `torch.Tensor` but is {type(lowerCamelCase      )}"""      )

         if isinstance(lowerCamelCase ,   PIL.Image.Image      ):
            __a				     =    preprocess(lowerCamelCase      )

         __a     ,			__a				     =    image.shape[-2:]

         # in_channels should be 6: 3 for latents, 3 for low resolution image
         __a				     =    (batch_size, self.unet.config.in_channels // 2, height, width)
         __a				     =    next(self.unet.parameters()      ).dtype

         __a				     =    randn_tensor(lowerCamelCase ,   generator=lowerCamelCase ,   device=self.device ,   dtype=lowerCamelCase      )

         __a				     =    image.to(device=self.device ,   dtype=lowerCamelCase      )

         # set timesteps and move to the correct device
         self.scheduler.set_timesteps(lowerCamelCase ,   device=self.device      )
         __a				     =    self.scheduler.timesteps

         # scale the initial noise by the standard deviation required by the scheduler
         __a				     =    latents * self.scheduler.init_noise_sigma

         # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature.
         # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
         # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
         # and should be between [0, 1]
         __a				     =    'eta' in set(inspect.signature(self.scheduler.step      ).parameters.keys()      )
         __a				     =    {}
         if accepts_eta:
            __a				     =    eta

         for t in self.progress_bar(lowerCamelCase      ):
            # concat latents and low resolution image in the channel dimension.
            __a				     =    torch.cat([latents, image] ,   dim=1      )
            __a				     =    self.scheduler.scale_model_input(lowerCamelCase ,   lowerCamelCase      )
            # predict the noise residual
            __a				     =    self.unet(lowerCamelCase ,   lowerCamelCase      ).sample
            # compute the previous noisy sample x_t -> x_t-1
            __a				     =    self.scheduler.step(lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   **lowerCamelCase      ).prev_sample

         # decode the image latents with the VQVAE
         __a				     =    self.vqvae.decode(lowerCamelCase      ).sample
         __a				     =    torch.clamp(lowerCamelCase ,   -1.0 ,   1.0      )
         __a				     =    image / 2 + 0.5
         __a				     =    image.cpu().permute(0 ,   2 ,   3 ,   1      ).numpy()

         if output_type == "pil":
            __a				     =    self.numpy_to_pil(lowerCamelCase      )

         if not return_dict:
            return (image,)

         return ImagePipelineOutput(images=lowerCamelCase      )