



'''simple docstring'''





import os
import time
import warnings
from dataclasses import dataclass, field
from enum import Enum
from typing import List, Optional, Union

import torch
from filelock import FileLock
from torch.utils.data import Dataset

from ...tokenization_utils_base import PreTrainedTokenizerBase
from ...utils import logging
from ..processors.glue import glue_convert_examples_to_features, glue_output_modes, glue_processors
from ..processors.utils import InputFeatures


lowercase_									=    logging.get_logger(__name__)






@dataclass
class __A     :



 '''simple docstring'''







 __lowerCamelCase       :			str		=			field(metadata={'help': 'The name of the task to train on: ' + ', '.join(glue_processors.keys()		)}		)
 __lowerCamelCase       :			str		=			field(
     metadata={'help': 'The input data dir. Should contain the .tsv files (or other data files) for the task.'}		)
 __lowerCamelCase       :			int		=			field(
     default=128  ,  metadata={
         'help': (
             'The maximum total input sequence length after tokenization. Sequences longer '
             'than this will be truncated, sequences shorter will be padded.'
         )
     }  ,  )
 __lowerCamelCase       :			bool		=			field(
     default=A  ,  metadata={'help': 'Overwrite the cached training and evaluation sets'}		)



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


      """simple docstring"""



      _a           =    self.task_name.lower()






class __A     (    A		):



 '''simple docstring'''







 __lowerCamelCase       :			List[Any]		=			'train'
 __lowerCamelCase       :			Tuple		=			'dev'
 __lowerCamelCase       :			Tuple		=			'test'






class __A     (    A		):



 '''simple docstring'''







 __lowerCamelCase       :			GlueDataTrainingArguments
 __lowerCamelCase       :			str
 __lowerCamelCase       :			List[InputFeatures]



 def __init__(self					,  A					,  A					,  A = None					,  A = Split.train					,  A = None					,  )       ->	Optional[Any]:


      """simple docstring"""



      warnings.warn(
          '''This dataset will be removed from the library soon, preprocessing should be handled with the 🤗 Datasets '''
          '''library. You can have a look at this example script for pointers: '''
          '''https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py'''					,  A					,  )
      _a           =    args
      _a           =    glue_processors[args.task_name]()
      _a           =    glue_output_modes[args.task_name]
      if isinstance(A					,  A			):
           try:
                _a           =    Split[mode]
           except KeyError:
                raise KeyError('''mode is not a valid split name'''			)
        # Load data features from cache or dataset file
      _a           =    os.path.join(
          cache_dir if cache_dir is not None else args.data_dir					,  f'''cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{args.task_name}'''					,  )
      _a           =    self.processor.get_labels()
      if args.task_name in ["mnli", "mnli-mm"] and tokenizer.__class__.__name__ in (
          "RobertaTokenizer",
          "RobertaTokenizerFast",
          "XLMRobertaTokenizer",
          "BartTokenizer",
          "BartTokenizerFast",
      ):
           # HACK(label indices are swapped in RoBERTa pretrained model)
           _a    ,       _a           =    label_list[2], label_list[1]
      _a           =    label_list

      # Make sure only the first process in distributed training processes the dataset,
      # and the others will use the cache.
      _a           =    cached_features_file + '''.lock'''
      with FileLock(A			):
           if os.path.exists(A			) and not args.overwrite_cache:
                _a           =    time.time()
                _a           =    torch.load(A			)
                logger.info(
                    f'''Loading features from cached file {cached_features_file} [took %.3f s]'''					,  time.time() - start			)
           else:
                logger.info(f'''Creating features from dataset file at {args.data_dir}'''			)

                if mode == Split.dev:
                     _a           =    self.processor.get_dev_examples(args.data_dir			)
                elif mode == Split.test:
                     _a           =    self.processor.get_test_examples(args.data_dir			)
                else:
                     _a           =    self.processor.get_train_examples(args.data_dir			)
                if limit_length is not None:
                     _a           =    examples[:limit_length]
                _a           =    glue_convert_examples_to_features(
                    A					,  A					,  max_length=args.max_seq_length					,  label_list=A					,  output_mode=self.output_mode					,  )
                _a           =    time.time()
                torch.save(self.features					,  A			)
                # ^ This seems to take a lot of time so I want to investigate why and how we can improve.
                logger.info(
                    f'''Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]'''			)



 def __len__(self			)       ->	Any:


      """simple docstring"""



      return len(self.features			)



 def __getitem__(self					,  A			)       ->	InputFeatures:


      """simple docstring"""



      return self.features[i]



 def    a__    (self			)       ->	int:


      """simple docstring"""



      return self.label_list








'''simple docstring'''





import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.utils import (
    PIL_INTERPOLATION,
    randn_tensor,
)




def lowerCAmelCase    (__A    ,      __A    ,      __A):



     """simple docstring"""



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

     if isinstance(image[0]    ,      PIL.Image.Image):
          _a           =    [np.array(i.resize((w, h)    ,      resample=PIL_INTERPOLATION['''lanczos''']))[None, :] for i in image]
          _a           =    np.concatenate(__A    ,      axis=0)
          _a           =    np.array(__A).astype(np.floataa) / 2_55.0
          _a           =    image.transpose(0    ,      3    ,      1    ,      2)
          _a           =    2.0 * image - 1.0
          _a           =    torch.from_numpy(__A)
     elif isinstance(image[0]    ,      torch.Tensor):
          _a           =    torch.cat(__A    ,      dim=0)
     return image




def lowerCAmelCase    (__A    ,      __A    ,      __A    ,      __A=0.99_95):



     """simple docstring"""



     if not isinstance(__A    ,      np.ndarray):
          _a           =    True
          _a           =    va.device
          _a           =    va.cpu().numpy()
          _a           =    va.cpu().numpy()

     _a           =    np.sum(va * va / (np.linalg.norm(__A) * np.linalg.norm(__A)))
     if np.abs(__A) > DOT_THRESHOLD:
          _a           =    (1 - t) * va + t * va
     else:
          _a           =    np.arccos(__A)
          _a           =    np.sin(__A)
          _a           =    theta_a * t
          _a           =    np.sin(__A)
          _a           =    np.sin(theta_a - theta_t) / sin_theta_a
          _a           =    sin_theta_t / sin_theta_a
          _a           =    sa * va + sa * va

     if inputs_are_torch:
          _a           =    torch.from_numpy(__A).to(__A)

     return va




def lowerCAmelCase    (__A    ,      __A):



     """simple docstring"""



     _a           =    F.normalize(__A    ,      dim=-1)
     _a           =    F.normalize(__A    ,      dim=-1)
     return (x - y).norm(dim=-1).div(2).arcsin().pow(2).mul(2)




def lowerCAmelCase    (__A    ,      __A):



     """simple docstring"""



     for param in model.parameters():
          _a           =    value






class __A     (    A		):



 '''simple docstring'''







 def __init__(self					,  A					,  A					,  A					,  A					,  A					,  A					,  A					,  A=None					,  A=None					,  A=None					,  )       ->	str:


      """simple docstring"""



      super().__init__()
      self.register_modules(
          vae=A					,  text_encoder=A					,  clip_model=A					,  tokenizer=A					,  unet=A					,  scheduler=A					,  feature_extractor=A					,  coca_model=A					,  coca_tokenizer=A					,  coca_transform=A					,  )
      _a           =    (
          feature_extractor.size
          if isinstance(feature_extractor.size					,  A			)
          else feature_extractor.size['''shortest_edge''']
      )
      _a           =    transforms.Normalize(mean=feature_extractor.image_mean					,  std=feature_extractor.image_std			)
      set_requires_grad(self.text_encoder					,  A			)
      set_requires_grad(self.clip_model					,  A			)



 def    a__    (self					,  A = "auto"			)       ->	Union[str, Any]:


      """simple docstring"""



      if slice_size == "auto":
           # half the attention head size is usually a good trade-off between
           # speed and memory
           _a           =    self.unet.config.attention_head_dim // 2
      self.unet.set_attention_slice(A			)



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


      """simple docstring"""



      self.enable_attention_slicing(A			)



 def    a__    (self			)       ->	int:


      """simple docstring"""



      set_requires_grad(self.vae					,  A			)



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


      """simple docstring"""



      set_requires_grad(self.vae					,  A			)



 def    a__    (self			)       ->	Dict:


      """simple docstring"""



      set_requires_grad(self.unet					,  A			)



 def    a__    (self			)       ->	str:


      """simple docstring"""



      set_requires_grad(self.unet					,  A			)



 def    a__    (self					,  A					,  A					,  A			)       ->	Optional[Any]:


      """simple docstring"""



      _a           =    min(int(num_inference_steps * strength			)					,  A			)

      _a           =    max(num_inference_steps - init_timestep					,  0			)
      _a           =    self.scheduler.timesteps[t_start:]

      return timesteps, num_inference_steps - t_start



 def    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A=None			)       ->	List[str]:


      """simple docstring"""



      if not isinstance(A					,  torch.Tensor			):
           raise ValueError(f'''`image` has to be of type `torch.Tensor` but is {type(A			)}'''			)

      _a           =    image.to(device=A					,  dtype=A			)

      if isinstance(A					,  A			):
           _a           =    [
               self.vae.encode(image[i : i + 1]			).latent_dist.sample(generator[i]			) for i in range(A			)
           ]
           _a           =    torch.cat(A					,  dim=0			)
      else:
           _a           =    self.vae.encode(A			).latent_dist.sample(A			)

      # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
      _a           =    0.18215 * init_latents
      _a           =    init_latents.repeat_interleave(A					,  dim=0			)

      _a           =    randn_tensor(init_latents.shape					,  generator=A					,  device=A					,  dtype=A			)

      # get latents
      _a           =    self.scheduler.add_noise(A					,  A					,  A			)
      _a           =    init_latents

      return latents



 def    a__    (self					,  A			)       ->	Tuple:


      """simple docstring"""



      _a           =    self.coca_transform(A			).unsqueeze(0			)
      with torch.no_grad(), torch.cuda.amp.autocast():
           _a           =    self.coca_model.generate(transformed_image.to(device=self.device					,  dtype=self.coca_model.dtype			)			)
      _a           =    self.coca_tokenizer.decode(generated[0].cpu().numpy()			)
      return generated.split('''<end_of_text>'''			)[0].replace('''<start_of_text>'''					,  ''''''			).rstrip(''' .,'''			)



 def    a__    (self					,  A					,  A			)       ->	List[Any]:


      """simple docstring"""



      _a           =    self.feature_extractor.preprocess(A			)
      _a           =    torch.from_numpy(clip_image_input['''pixel_values'''][0]			).unsqueeze(0			).to(self.device			).half()
      _a           =    self.clip_model.get_image_features(A			)
      _a           =    image_embeddings_clip / image_embeddings_clip.norm(p=2					,  dim=-1					,  keepdim=A			)
      _a           =    image_embeddings_clip.repeat_interleave(A					,  dim=0			)
      return image_embeddings_clip



 @torch.enable_grad()
 def    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A					,  A					,  )       ->	Union[str, Any]:


      """simple docstring"""



      _a           =    latents.detach().requires_grad_()

      _a           =    self.scheduler.scale_model_input(A					,  A			)

      # predict the noise residual
      _a           =    self.unet(A					,  A					,  encoder_hidden_states=A			).sample

      if isinstance(self.scheduler					,  (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)			):
           _a           =    self.scheduler.alphas_cumprod[timestep]
           _a           =    1 - alpha_prod_t
           # compute predicted original sample from predicted noise also called
           # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
           _a           =    (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

           _a           =    torch.sqrt(A			)
           _a           =    pred_original_sample * (fac) + latents * (1 - fac)
      elif isinstance(self.scheduler					,  A			):
           _a           =    self.scheduler.sigmas[index]
           _a           =    latents - sigma * noise_pred
      else:
           raise ValueError(f'''scheduler type {type(self.scheduler			)} not supported'''			)

      # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
      _a           =    1 / 0.18215 * sample
      _a           =    self.vae.decode(A			).sample
      _a           =    (image / 2 + 0.5).clamp(0					,  1			)

      _a           =    transforms.Resize(self.feature_extractor_size			)(A			)
      _a           =    self.normalize(A			).to(latents.dtype			)

      _a           =    self.clip_model.get_image_features(A			)
      _a           =    image_embeddings_clip / image_embeddings_clip.norm(p=2					,  dim=-1					,  keepdim=A			)

      _a           =    spherical_dist_loss(A					,  A			).mean() * clip_guidance_scale

      _a           =    -torch.autograd.grad(A					,  A			)[0]

      if isinstance(self.scheduler					,  A			):
           _a           =    latents.detach() + grads * (sigma**2)
           _a           =    noise_pred_original
      else:
           _a           =    noise_pred_original - torch.sqrt(A			) * grads
      return noise_pred, latents



 @torch.no_grad()
 def __call__(self					,  A					,  A					,  A = None					,  A = None					,  A = 512					,  A = 512					,  A = 0.6					,  A = 50					,  A = 7.5					,  A = 1					,  A = 0.0					,  A = 100					,  A = None					,  A = "pil"					,  A = True					,  A = 0.8					,  A = 0.1					,  A = 0.1					,  )       ->	str:


      """simple docstring"""



      if isinstance(A					,  A			) and len(A			) != batch_size:
           raise ValueError(f'''You have passed {batch_size} batch_size, but only {len(A			)} generators.'''			)

      if height % 8 != 0 or width % 8 != 0:
           raise ValueError(f'''`height` and `width` have to be divisible by 8 but are {height} and {width}.'''			)

      if isinstance(A					,  torch.Generator			) and batch_size > 1:
           _a           =    [generator] + [None] * (batch_size - 1)

      _a           =    [
          ('''model''', self.coca_model is None),
          ('''tokenizer''', self.coca_tokenizer is None),
          ('''transform''', self.coca_transform is None),
      ]
      _a           =    [x[0] for x in coca_is_none if x[1]]
      _a           =    ''', '''.join(A			)
      # generate prompts with coca model if prompt is None
      if content_prompt is None:
           if len(A			):
                raise ValueError(
                    f'''Content prompt is None and CoCa [{coca_is_none_str}] is None.'''
                    f'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'''			)
           _a           =    self.get_image_description(A			)
      if style_prompt is None:
           if len(A			):
                raise ValueError(
                    f'''Style prompt is None and CoCa [{coca_is_none_str}] is None.'''
                    f''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'''			)
           _a           =    self.get_image_description(A			)

      # get prompt text embeddings for content and style
      _a           =    self.tokenizer(
          A					,  padding='''max_length'''					,  max_length=self.tokenizer.model_max_length					,  truncation=A					,  return_tensors='''pt'''					,  )
      _a           =    self.text_encoder(content_text_input.input_ids.to(self.device			)			)[0]

      _a           =    self.tokenizer(
          A					,  padding='''max_length'''					,  max_length=self.tokenizer.model_max_length					,  truncation=A					,  return_tensors='''pt'''					,  )
      _a           =    self.text_encoder(style_text_input.input_ids.to(self.device			)			)[0]

      _a           =    slerp(A					,  A					,  A			)

      # duplicate text embeddings for each generation per prompt
      _a           =    text_embeddings.repeat_interleave(A					,  dim=0			)

      # set timesteps
      _a           =    '''offset''' in set(inspect.signature(self.scheduler.set_timesteps			).parameters.keys()			)
      _a           =    {}
      if accepts_offset:
           _a           =    1

      self.scheduler.set_timesteps(A					,  **A			)
      # Some schedulers like PNDM have timesteps as arrays
      # It's more optimized to move all timesteps to correct device beforehand
      self.scheduler.timesteps.to(self.device			)

      _a    ,       _a           =    self.get_timesteps(A					,  A					,  self.device			)
      _a           =    timesteps[:1].repeat(A			)

      # Preprocess image
      _a           =    preprocess(A					,  A					,  A			)
      _a           =    self.prepare_latents(
          A					,  A					,  A					,  text_embeddings.dtype					,  self.device					,  A			)

      _a           =    preprocess(A					,  A					,  A			)
      _a           =    self.prepare_latents(
          A					,  A					,  A					,  text_embeddings.dtype					,  self.device					,  A			)

      _a           =    slerp(A					,  A					,  A			)

      if clip_guidance_scale > 0:
           _a           =    self.get_clip_image_embeddings(A					,  A			)
           _a           =    self.get_clip_image_embeddings(A					,  A			)
           _a           =    slerp(
               A					,  A					,  A			)

      # 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.
      _a           =    guidance_scale > 1.0
      # get unconditional embeddings for classifier free guidance
      if do_classifier_free_guidance:
           _a           =    content_text_input.input_ids.shape[-1]
           _a           =    self.tokenizer(['''''']					,  padding='''max_length'''					,  max_length=A					,  return_tensors='''pt'''			)
           _a           =    self.text_encoder(uncond_input.input_ids.to(self.device			)			)[0]
           # duplicate unconditional embeddings for each generation per prompt
           _a           =    uncond_embeddings.repeat_interleave(A					,  dim=0			)

           # 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
           _a           =    torch.cat([uncond_embeddings, text_embeddings]			)

      # get the initial random noise unless the user supplied it

      # Unlike in other pipelines, latents need to be generated in the target device
      # for 1-to-1 results reproducibility with the CompVis implementation.
      # However this currently doesn't work in `mps`.
      _a           =    (batch_size, self.unet.config.in_channels, height // 8, width // 8)
      _a           =    text_embeddings.dtype
      if latents is None:
           if self.device.type == "mps":
                # randn does not work reproducibly on mps
                _a           =    torch.randn(A					,  generator=A					,  device='''cpu'''					,  dtype=A			).to(
                    self.device			)
           else:
                _a           =    torch.randn(A					,  generator=A					,  device=self.device					,  dtype=A			)
      else:
           if latents.shape != latents_shape:
                raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''			)
           _a           =    latents.to(self.device			)

      # 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

      # check if the scheduler accepts generator
      _a           =    '''generator''' in set(inspect.signature(self.scheduler.step			).parameters.keys()			)
      if accepts_generator:
           _a           =    generator

      with self.progress_bar(total=A			):
           for i, t in enumerate(A			):
                # expand the latents if we are doing classifier free guidance
                _a           =    torch.cat([latents] * 2			) if do_classifier_free_guidance else latents
                _a           =    self.scheduler.scale_model_input(A					,  A			)

                # predict the noise residual
                _a           =    self.unet(A					,  A					,  encoder_hidden_states=A			).sample

                # perform classifier free guidance
                if do_classifier_free_guidance:
                     _a    ,       _a           =    noise_pred.chunk(2			)
                     _a           =    noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

                # perform clip guidance
                if clip_guidance_scale > 0:
                     _a           =    (
                         text_embeddings.chunk(2			)[1] if do_classifier_free_guidance else text_embeddings
                     )
                     _a    ,       _a           =    self.cond_fn(
                         A					,  A					,  A					,  A					,  A					,  A					,  A					,  )

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

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
      _a           =    1 / 0.18215 * latents
      _a           =    self.vae.decode(A			).sample

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

      if output_type == "pil":
           _a           =    self.numpy_to_pil(A			)

      if not return_dict:
           return (image, None)

      return StableDiffusionPipelineOutput(images=A					,  nsfw_content_detected=A			)



