'''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 (							UpperCamelCase__				,  UpperCamelCase__				,  UpperCamelCase__				)	->    int:
    if isinstance(UpperCamelCase__				,  torch.Tensor				):
        return image
    elif isinstance(UpperCamelCase__				,  PIL.Image.Image				):
        __lowerCamelCase		=  [image]

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






def __lowerCAmelCase (							UpperCamelCase__				,  UpperCamelCase__				,  UpperCamelCase__				,  UpperCamelCase__=0.9_9_9_5				)	->    Dict:
    if not isinstance(UpperCamelCase__				,  np.ndarray				):
        __lowerCamelCase		=  True
        __lowerCamelCase		=  va.device
        __lowerCamelCase		=  va.cpu().numpy()
        __lowerCamelCase		=  va.cpu().numpy()

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

    if inputs_are_torch:
        __lowerCamelCase		=  torch.from_numpy(UpperCamelCase__				).to(UpperCamelCase__				)

    return va






def __lowerCAmelCase (							UpperCamelCase__				,  UpperCamelCase__				)	->    List[Any]:
    __lowerCamelCase		=  F.normalize(UpperCamelCase__				,  dim=-1				)
    __lowerCamelCase		=  F.normalize(UpperCamelCase__				,  dim=-1				)
    return (x - y).norm(dim=-1				).div(2				).arcsin().pow(2				).mul(2				)






def __lowerCAmelCase (							UpperCamelCase__				,  UpperCamelCase__				)	->    str:
    for param in model.parameters():
        __lowerCamelCase		=  value




class     a__      (   UpperCAmelCase__ ):






     def __init__( self		:		int  ,				a		:		AutoencoderKL  ,				a		:		CLIPTextModel  ,				a		:		CLIPModel  ,				a		:		CLIPTokenizer  ,				a		:		UNetaDConditionModel  ,				a		:		Union[PNDMScheduler, LMSDiscreteScheduler, DDIMScheduler, DPMSolverMultistepScheduler]  ,				a		:		CLIPFeatureExtractor  ,				a		:		Any=None  ,				a		:		str=None  ,				a		:		int=None  ,				):





         """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  ,				)
         __lowerCamelCase		=  (
             feature_extractor.size
             if isinstance(feature_extractor.size  ,				a    )
             else feature_extractor.size['''shortest_edge''']
         )
         __lowerCamelCase		=  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    SCREAMING_SNAKE_CASE__   ( self		:		str  ,				a		:		Optional[Union[str, int]] = "auto"    ):





         """simple docstring"""



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






     def    SCREAMING_SNAKE_CASE__   ( self		:		Any    ):





         """simple docstring"""



         self.enable_attention_slicing(a    )






     def    SCREAMING_SNAKE_CASE__   ( self		:		Optional[Any]    ):





         """simple docstring"""



         set_requires_grad(self.vae  ,				a    )






     def    SCREAMING_SNAKE_CASE__   ( self		:		Any    ):





         """simple docstring"""



         set_requires_grad(self.vae  ,				a    )






     def    SCREAMING_SNAKE_CASE__   ( self		:		int    ):





         """simple docstring"""



         set_requires_grad(self.unet  ,				a    )






     def    SCREAMING_SNAKE_CASE__   ( self		:		Union[str, Any]    ):





         """simple docstring"""



         set_requires_grad(self.unet  ,				a    )






     def    SCREAMING_SNAKE_CASE__   ( self		:		int  ,				a		:		Dict  ,				a		:		List[str]  ,				a		:		Tuple    ):





         """simple docstring"""



         __lowerCamelCase		=  min(int(num_inference_steps * strength    )  ,				a    )

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

         return timesteps, num_inference_steps - t_start






     def    SCREAMING_SNAKE_CASE__   ( self		:		Any  ,				a		:		int  ,				a		:		Dict  ,				a		:		List[str]  ,				a		:		int  ,				a		:		str  ,				a		:		int=None    ):





         """simple docstring"""



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

         __lowerCamelCase		=  image.to(device=a  ,				dtype=a    )

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

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

         __lowerCamelCase		=  randn_tensor(init_latents.shape  ,				generator=a  ,				device=a  ,				dtype=a    )

         # get latents
         __lowerCamelCase		=  self.scheduler.add_noise(a  ,				a  ,				a    )
         __lowerCamelCase		=  init_latents

         return latents






     def    SCREAMING_SNAKE_CASE__   ( self		:		Optional[Any]  ,				a		:		List[str]    ):





         """simple docstring"""



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






     def    SCREAMING_SNAKE_CASE__   ( self		:		str  ,				a		:		Union[str, Any]  ,				a		:		Optional[int]    ):





         """simple docstring"""



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






     @torch.enable_grad()
     def    SCREAMING_SNAKE_CASE__   ( self		:		Dict  ,				a		:		Optional[int]  ,				a		:		List[Any]  ,				a		:		Union[str, Any]  ,				a		:		str  ,				a		:		Tuple  ,				a		:		Optional[Any]  ,				a		:		List[str]  ,				):





         """simple docstring"""



         __lowerCamelCase		=  latents.detach().requires_grad_()

         __lowerCamelCase		=  self.scheduler.scale_model_input(a  ,				a    )

         # predict the noise residual
         __lowerCamelCase		=  self.unet(a  ,				a  ,				encoder_hidden_states=a    ).sample

         if isinstance(self.scheduler  ,				(PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)    ):
             __lowerCamelCase		=  self.scheduler.alphas_cumprod[timestep]
             __lowerCamelCase		=  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
             __lowerCamelCase		=  (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

             __lowerCamelCase		=  torch.sqrt(a    )
             __lowerCamelCase		=  pred_original_sample * (fac) + latents * (1 - fac)
         elif isinstance(self.scheduler  ,				a    ):
             __lowerCamelCase		=  self.scheduler.sigmas[index]
             __lowerCamelCase		=  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
         __lowerCamelCase		=  1 / 0.1_82_15 * sample
         __lowerCamelCase		=  self.vae.decode(a    ).sample
         __lowerCamelCase		=  (image / 2 + 0.5).clamp(0  ,				1    )

         __lowerCamelCase		=  transforms.Resize(self.feature_extractor_size    )(a    )
         __lowerCamelCase		=  self.normalize(a    ).to(latents.dtype    )

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

         __lowerCamelCase		=  spherical_dist_loss(a  ,				a    ).mean() * clip_guidance_scale

         __lowerCamelCase		=  -torch.autograd.grad(a  ,				a    )[0]

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






     @torch.no_grad()
     def __call__( self		:		Union[str, Any]  ,				a		:		Union[torch.FloatTensor, PIL.Image.Image]  ,				a		:		Union[torch.FloatTensor, PIL.Image.Image]  ,				a		:		Optional[str] = None  ,				a		:		Optional[str] = None  ,				a		:		Optional[int] = 5_12  ,				a		:		Optional[int] = 5_12  ,				a		:		float = 0.6  ,				a		:		Optional[int] = 50  ,				a		:		Optional[float] = 7.5  ,				a		:		Optional[int] = 1  ,				a		:		float = 0.0  ,				a		:		Optional[float] = 1_00  ,				a		:		Optional[torch.Generator] = None  ,				a		:		Optional[str] = "pil"  ,				a		:		bool = True  ,				a		:		float = 0.8  ,				a		:		float = 0.1  ,				a		:		float = 0.1  ,				):





         """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:
             __lowerCamelCase		=  [generator] + [None] * (batch_size - 1)

         __lowerCamelCase		=  [
             ('''model''', self.coca_model is None),
             ('''tokenizer''', self.coca_tokenizer is None),
             ('''transform''', self.coca_transform is None),
         ]
         __lowerCamelCase		=  [x[0] for x in coca_is_none if x[1]]
         __lowerCamelCase		=  ''', '''.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."""    )
             __lowerCamelCase		=  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."""    )
             __lowerCamelCase		=  self.get_image_description(a    )

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

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

         __lowerCamelCase		=  slerp(a  ,				a  ,				a    )

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

         # set timesteps
         __lowerCamelCase		=  '''offset''' in set(inspect.signature(self.scheduler.set_timesteps    ).parameters.keys()    )
         __lowerCamelCase		=  {}
         if accepts_offset:
             __lowerCamelCase		=  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    )

         __lowerCamelCase	,  __lowerCamelCase		=  self.get_timesteps(a  ,				a  ,				self.device    )
         __lowerCamelCase		=  timesteps[:1].repeat(a    )

         # Preprocess image
         __lowerCamelCase		=  preprocess(a  ,				a  ,				a    )
         __lowerCamelCase		=  self.prepare_latents(
             a  ,				a  ,				a  ,				text_embeddings.dtype  ,				self.device  ,				a    )

         __lowerCamelCase		=  preprocess(a  ,				a  ,				a    )
         __lowerCamelCase		=  self.prepare_latents(
             a  ,				a  ,				a  ,				text_embeddings.dtype  ,				self.device  ,				a    )

         __lowerCamelCase		=  slerp(a  ,				a  ,				a    )

         if clip_guidance_scale > 0:
             __lowerCamelCase		=  self.get_clip_image_embeddings(a  ,				a    )
             __lowerCamelCase		=  self.get_clip_image_embeddings(a  ,				a    )
             __lowerCamelCase		=  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.
         __lowerCamelCase		=  guidance_scale > 1.0
         # get unconditional embeddings for classifier free guidance
         if do_classifier_free_guidance:
             __lowerCamelCase		=  content_text_input.input_ids.shape[-1]
             __lowerCamelCase		=  self.tokenizer(['''''']  ,				padding='''max_length'''  ,				max_length=a  ,				return_tensors='''pt'''    )
             __lowerCamelCase		=  self.text_encoder(uncond_input.input_ids.to(self.device    )    )[0]
             # duplicate unconditional embeddings for each generation per prompt
             __lowerCamelCase		=  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
             __lowerCamelCase		=  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`.
         __lowerCamelCase		=  (batch_size, self.unet.config.in_channels, height // 8, width // 8)
         __lowerCamelCase		=  text_embeddings.dtype
         if latents is None:
             if self.device.type == "mps":
                 # randn does not work reproducibly on mps
                 __lowerCamelCase		=  torch.randn(a  ,				generator=a  ,				device='''cpu'''  ,				dtype=a    ).to(
                     self.device    )
             else:
                 __lowerCamelCase		=  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}"""    )
             __lowerCamelCase		=  latents.to(self.device    )

         # scale the initial noise by the standard deviation required by the scheduler
         __lowerCamelCase		=  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]
         __lowerCamelCase		=  '''eta''' in set(inspect.signature(self.scheduler.step    ).parameters.keys()    )
         __lowerCamelCase		=  {}
         if accepts_eta:
             __lowerCamelCase		=  eta

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

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

                 # predict the noise residual
                 __lowerCamelCase		=  self.unet(a  ,				a  ,				encoder_hidden_states=a    ).sample

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

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

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

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

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

         if output_type == "pil":
             __lowerCamelCase		=  self.numpy_to_pil(a    )

         if not return_dict:
             return (image, None)

         return StableDiffusionPipelineOutput(images=a  ,				nsfw_content_detected=a    )




'''simple docstring'''



import os
import sys

__lowercase	:						List[Any]       =	os.path.join(os.path.dirname(__file__), 'src')
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


__lowercase	:						int       =	[
    'torch',
    'numpy',
    'tokenizers',
    'filelock',
    'requests',
    'tqdm',
    'regex',
    'sentencepiece',
    'sacremoses',
    'importlib_metadata',
    'huggingface_hub',
]






@add_start_docstrings(AutoConfig.__doc__   )
def   lowerCamelCase							(*_SCREAMING_SNAKE_CASE      :   List[str]						,      **_SCREAMING_SNAKE_CASE      :   List[Any]   ):
					return AutoConfig.from_pretrained(*_SCREAMING_SNAKE_CASE						,      **_SCREAMING_SNAKE_CASE   )






@add_start_docstrings(AutoTokenizer.__doc__   )
def   lowerCamelCase							(*_SCREAMING_SNAKE_CASE      :   str						,      **_SCREAMING_SNAKE_CASE      :   Any   ):
					return AutoTokenizer.from_pretrained(*_SCREAMING_SNAKE_CASE						,      **_SCREAMING_SNAKE_CASE   )






@add_start_docstrings(AutoModel.__doc__   )
def   lowerCamelCase							(*_SCREAMING_SNAKE_CASE      :   int						,      **_SCREAMING_SNAKE_CASE      :   Union[str, Any]   ):
					return AutoModel.from_pretrained(*_SCREAMING_SNAKE_CASE						,      **_SCREAMING_SNAKE_CASE   )






@add_start_docstrings(AutoModelForCausalLM.__doc__   )
def   lowerCamelCase							(*_SCREAMING_SNAKE_CASE      :   List[Any]						,      **_SCREAMING_SNAKE_CASE      :   Optional[int]   ):
					return AutoModelForCausalLM.from_pretrained(*_SCREAMING_SNAKE_CASE						,      **_SCREAMING_SNAKE_CASE   )






@add_start_docstrings(AutoModelForMaskedLM.__doc__   )
def   lowerCamelCase							(*_SCREAMING_SNAKE_CASE      :   Union[str, Any]						,      **_SCREAMING_SNAKE_CASE      :   List[Any]   ):
					return AutoModelForMaskedLM.from_pretrained(*_SCREAMING_SNAKE_CASE						,      **_SCREAMING_SNAKE_CASE   )






@add_start_docstrings(AutoModelForSequenceClassification.__doc__   )
def   lowerCamelCase							(*_SCREAMING_SNAKE_CASE      :   Optional[Any]						,      **_SCREAMING_SNAKE_CASE      :   Any   ):
					return AutoModelForSequenceClassification.from_pretrained(*_SCREAMING_SNAKE_CASE						,      **_SCREAMING_SNAKE_CASE   )






@add_start_docstrings(AutoModelForQuestionAnswering.__doc__   )
def   lowerCamelCase							(*_SCREAMING_SNAKE_CASE      :   Any						,      **_SCREAMING_SNAKE_CASE      :   List[str]   ):
					return AutoModelForQuestionAnswering.from_pretrained(*_SCREAMING_SNAKE_CASE						,      **_SCREAMING_SNAKE_CASE   )



