from typing import List, Optional, Union

import torch
from transformers import (
    XLMRobertaTokenizer,
)

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDIMScheduler, DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from .text_encoder import MultilingualCLIP


_lowerCAmelCase       =		logging.get_logger(__name__)  # pylint: disable=invalid-name

_lowerCAmelCase       =		'\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyPipeline, KandinskyPriorPipeline\n        >>> import torch\n\n        >>> pipe_prior = KandinskyPriorPipeline.from_pretrained("kandinsky-community/Kandinsky-2-1-prior")\n        >>> pipe_prior.to("cuda")\n\n        >>> prompt = "red cat, 4k photo"\n        >>> out = pipe_prior(prompt)\n        >>> image_emb = out.image_embeds\n        >>> negative_image_emb = out.negative_image_embeds\n\n        >>> pipe = KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1")\n        >>> pipe.to("cuda")\n\n        >>> image = pipe(\n        ...     prompt,\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=negative_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=100,\n        ... ).images\n\n        >>> image[0].save("cat.png")\n        ```\n'
def 					_snake_case	(  __snake_case  ,     __snake_case  ,     __snake_case=8						):
					_UpperCamelCase			     =     h // scale_factor**2
					if h % scale_factor**2 != 0:
										new_h += 1
					_UpperCamelCase			     =     w // scale_factor**2
					if w % scale_factor**2 != 0:
										new_w += 1
					return new_h * scale_factor, new_w * scale_factor







class     lowerCAmelCase_     (       __lowercase ):







							def __init__(   self      :     Optional[Any] ,			_A      :     MultilingualCLIP ,			_A      :     XLMRobertaTokenizer ,			_A      :     UNetaDConditionModel ,			_A      :     Union[DDIMScheduler, DDPMScheduler] ,			_A      :     VQModel ,			):
												super().__init__()

												self.register_modules(
												    text_encoder=__SCREAMING_SNAKE_CASE ,			tokenizer=__SCREAMING_SNAKE_CASE ,			unet=__SCREAMING_SNAKE_CASE ,			scheduler=__SCREAMING_SNAKE_CASE ,			movq=__SCREAMING_SNAKE_CASE ,			)
												_UpperCamelCase			     =     2 ** (len(self.movq.config.block_out_channels		) - 1)







							def  UpperCamelCase_						(   self      :     Tuple ,			_A      :     Dict ,			_A      :     Optional[int] ,			_A      :     List[str] ,			_A      :     List[Any] ,			_A      :     Any ,			_A      :     Optional[Any]		):




												if latents is None:
																	_UpperCamelCase			     =     randn_tensor(__SCREAMING_SNAKE_CASE ,			generator=__SCREAMING_SNAKE_CASE ,			device=__SCREAMING_SNAKE_CASE ,			dtype=__SCREAMING_SNAKE_CASE		)
												else:
																	if latents.shape != shape:
																						raise ValueError(F"""Unexpected latents shape, got {latents.shape}, expected {shape}"""		)
																	_UpperCamelCase			     =     latents.to(__SCREAMING_SNAKE_CASE		)

												_UpperCamelCase			     =     latents * scheduler.init_noise_sigma
												return latents







							def  UpperCamelCase_						(   self      :     Union[str, Any] ,			_A      :     Optional[Any] ,			_A      :     List[str] ,			_A      :     Any ,			_A      :     List[Any] ,			_A      :     Any=None ,			):
												_UpperCamelCase			     =     len(__SCREAMING_SNAKE_CASE		) if isinstance(__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE		) else 1
												# get prompt text embeddings
												_UpperCamelCase			     =     self.tokenizer(
												    __SCREAMING_SNAKE_CASE ,			padding='''max_length''' ,			truncation=__SCREAMING_SNAKE_CASE ,			max_length=77 ,			return_attention_mask=__SCREAMING_SNAKE_CASE ,			add_special_tokens=__SCREAMING_SNAKE_CASE ,			return_tensors='''pt''' ,			)

												_UpperCamelCase			     =     text_inputs.input_ids
												_UpperCamelCase			     =     self.tokenizer(__SCREAMING_SNAKE_CASE ,			padding='''longest''' ,			return_tensors='''pt'''		).input_ids

												if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE		):
																	_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}"""		)

												_UpperCamelCase			     =     text_input_ids.to(__SCREAMING_SNAKE_CASE		)
												_UpperCamelCase			     =     text_inputs.attention_mask.to(__SCREAMING_SNAKE_CASE		)

												_UpperCamelCase     ,    _UpperCamelCase			     =     self.text_encoder(
												    input_ids=__SCREAMING_SNAKE_CASE ,			attention_mask=__SCREAMING_SNAKE_CASE		)

												_UpperCamelCase			     =     prompt_embeds.repeat_interleave(__SCREAMING_SNAKE_CASE ,			dim=0		)
												_UpperCamelCase			     =     text_encoder_hidden_states.repeat_interleave(__SCREAMING_SNAKE_CASE ,			dim=0		)
												_UpperCamelCase			     =     text_mask.repeat_interleave(__SCREAMING_SNAKE_CASE ,			dim=0		)

												if do_classifier_free_guidance:
																	_UpperCamelCase			     =     42
																	if negative_prompt is None:
																						_UpperCamelCase			     =     [''''''] * batch_size
																	elif type(__SCREAMING_SNAKE_CASE		) is not type(__SCREAMING_SNAKE_CASE		):
																						raise TypeError(
																						    F"""`negative_prompt` should be the same type to `prompt`, but got {type(__SCREAMING_SNAKE_CASE		)} !="""
																						    F""" {type(__SCREAMING_SNAKE_CASE		)}."""		)
																	elif isinstance(__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE		):
																						_UpperCamelCase			     =     [negative_prompt]
																	elif batch_size != len(__SCREAMING_SNAKE_CASE		):
																						raise ValueError(
																						    F"""`negative_prompt`: {negative_prompt} has batch size {len(__SCREAMING_SNAKE_CASE		)}, 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			     =     self.tokenizer(
																	    __SCREAMING_SNAKE_CASE ,			padding='''max_length''' ,			max_length=77 ,			truncation=__SCREAMING_SNAKE_CASE ,			return_attention_mask=__SCREAMING_SNAKE_CASE ,			add_special_tokens=__SCREAMING_SNAKE_CASE ,			return_tensors='''pt''' ,			)
																	_UpperCamelCase			     =     uncond_input.input_ids.to(__SCREAMING_SNAKE_CASE		)
																	_UpperCamelCase			     =     uncond_input.attention_mask.to(__SCREAMING_SNAKE_CASE		)

																	_UpperCamelCase     ,    _UpperCamelCase			     =     self.text_encoder(
																	    input_ids=__SCREAMING_SNAKE_CASE ,			attention_mask=__SCREAMING_SNAKE_CASE		)

																	# duplicate unconditional embeddings for each generation per prompt, using mps friendly method

																	_UpperCamelCase			     =     negative_prompt_embeds.shape[1]
																	_UpperCamelCase			     =     negative_prompt_embeds.repeat(1 ,			__SCREAMING_SNAKE_CASE		)
																	_UpperCamelCase			     =     negative_prompt_embeds.view(batch_size * num_images_per_prompt ,			__SCREAMING_SNAKE_CASE		)

																	_UpperCamelCase			     =     uncond_text_encoder_hidden_states.shape[1]
																	_UpperCamelCase			     =     uncond_text_encoder_hidden_states.repeat(1 ,			__SCREAMING_SNAKE_CASE ,			1		)
																	_UpperCamelCase			     =     uncond_text_encoder_hidden_states.view(
																	    batch_size * num_images_per_prompt ,			__SCREAMING_SNAKE_CASE ,			-1		)
																	_UpperCamelCase			     =     uncond_text_mask.repeat_interleave(__SCREAMING_SNAKE_CASE ,			dim=0		)

																	# done duplicates

																	# 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]		)
																	_UpperCamelCase			     =     torch.cat([uncond_text_encoder_hidden_states, text_encoder_hidden_states]		)

																	_UpperCamelCase			     =     torch.cat([uncond_text_mask, text_mask]		)

												return prompt_embeds, text_encoder_hidden_states, text_mask







							def  UpperCamelCase_						(   self      :     Optional[int] ,			_A      :     Dict=0		):




												if is_accelerate_available():
																	from accelerate import cpu_offload
												else:
																	raise ImportError('''Please install accelerate via `pip install accelerate`'''		)

												_UpperCamelCase			     =     torch.device(F"""cuda:{gpu_id}"""		)

												_UpperCamelCase			     =     [
												    self.unet,
												    self.text_encoder,
												    self.movq,
												]
												for cpu_offloaded_model in models:
																	if cpu_offloaded_model is not None:
																						cpu_offload(__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE		)







							def  UpperCamelCase_						(   self      :     List[Any] ,			_A      :     Union[str, Any]=0		):




												if is_accelerate_available() and is_accelerate_version('''>=''' ,			'''0.17.0.dev0'''		):
																	from accelerate import cpu_offload_with_hook
												else:
																	raise ImportError('''`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.'''		)

												_UpperCamelCase			     =     torch.device(F"""cuda:{gpu_id}"""		)

												if self.device.type != "cpu":
																	self.to('''cpu''' ,			silence_dtype_warnings=__SCREAMING_SNAKE_CASE		)
																	torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

												_UpperCamelCase			     =     None
												for cpu_offloaded_model in [self.text_encoder, self.unet, self.movq]:
																	_UpperCamelCase     ,    _UpperCamelCase			     =     cpu_offload_with_hook(__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE ,			prev_module_hook=__SCREAMING_SNAKE_CASE		)

												if self.safety_checker is not None:
																	_UpperCamelCase     ,    _UpperCamelCase			     =     cpu_offload_with_hook(self.safety_checker ,			__SCREAMING_SNAKE_CASE ,			prev_module_hook=__SCREAMING_SNAKE_CASE		)

												# We'll offload the last model manually.
												_UpperCamelCase			     =     hook







							@property
							# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
							def  UpperCamelCase_						(   self      :     List[Any]		):




												if not hasattr(self.unet ,			'''_hf_hook'''		):
																	return self.device
												for module in self.unet.modules():
																	if (
																	    hasattr(__SCREAMING_SNAKE_CASE ,			'''_hf_hook'''		)
																	    and hasattr(module._hf_hook ,			'''execution_device'''		)
																	    and module._hf_hook.execution_device is not None
																	):
																						return torch.device(module._hf_hook.execution_device		)
												return self.device







							@torch.no_grad()
							@replace_example_docstring(__SCREAMING_SNAKE_CASE		)
							def __call__(   self      :     Optional[int] ,			_A      :     Union[str, List[str]] ,			_A      :     Union[torch.FloatTensor, List[torch.FloatTensor]] ,			_A      :     Union[torch.FloatTensor, List[torch.FloatTensor]] ,			_A      :     Optional[Union[str, List[str]]] = None ,			_A      :     int = 512 ,			_A      :     int = 512 ,			_A      :     int = 100 ,			_A      :     float = 4.0 ,			_A      :     int = 1 ,			_A      :     Optional[Union[torch.Generator, List[torch.Generator]]] = None ,			_A      :     Optional[torch.FloatTensor] = None ,			_A      :     Optional[str] = "pil" ,			_A      :     bool = True ,			):




												if isinstance(__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE		):
																	_UpperCamelCase			     =     1
												elif isinstance(__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE		):
																	_UpperCamelCase			     =     len(__SCREAMING_SNAKE_CASE		)
												else:
																	raise ValueError(F"""`prompt` has to be of type `str` or `list` but is {type(__SCREAMING_SNAKE_CASE		)}"""		)

												_UpperCamelCase			     =     self._execution_device

												_UpperCamelCase			     =     batch_size * num_images_per_prompt
												_UpperCamelCase			     =     guidance_scale > 1.0

												_UpperCamelCase     ,    _UpperCamelCase     ,    _UpperCamelCase			     =     self._encode_prompt(
												    __SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE		)

												if isinstance(__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE		):
																	_UpperCamelCase			     =     torch.cat(__SCREAMING_SNAKE_CASE ,			dim=0		)
												if isinstance(__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE		):
																	_UpperCamelCase			     =     torch.cat(__SCREAMING_SNAKE_CASE ,			dim=0		)

												if do_classifier_free_guidance:
																	_UpperCamelCase			     =     image_embeds.repeat_interleave(__SCREAMING_SNAKE_CASE ,			dim=0		)
																	_UpperCamelCase			     =     negative_image_embeds.repeat_interleave(__SCREAMING_SNAKE_CASE ,			dim=0		)

												_UpperCamelCase			     =     torch.cat([negative_image_embeds, image_embeds] ,			dim=0		).to(
												    dtype=prompt_embeds.dtype ,			device=__SCREAMING_SNAKE_CASE		)

												self.scheduler.set_timesteps(__SCREAMING_SNAKE_CASE ,			device=__SCREAMING_SNAKE_CASE		)
												_UpperCamelCase			     =     self.scheduler.timesteps

												_UpperCamelCase			     =     self.unet.config.in_channels

												_UpperCamelCase     ,    _UpperCamelCase			     =     get_new_h_w(__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE ,			self.movq_scale_factor		)

												# create initial latent
												_UpperCamelCase			     =     self.prepare_latents(
												    (batch_size, num_channels_latents, height, width) ,			text_encoder_hidden_states.dtype ,			__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE ,			self.scheduler ,			)

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

																	_UpperCamelCase			     =     {'''text_embeds''': prompt_embeds, '''image_embeds''': image_embeds}
																	_UpperCamelCase			     =     self.unet(
																	    sample=__SCREAMING_SNAKE_CASE ,			timestep=__SCREAMING_SNAKE_CASE ,			encoder_hidden_states=__SCREAMING_SNAKE_CASE ,			added_cond_kwargs=__SCREAMING_SNAKE_CASE ,			return_dict=__SCREAMING_SNAKE_CASE ,			)[0]

																	if do_classifier_free_guidance:
																						_UpperCamelCase     ,    _UpperCamelCase			     =     noise_pred.split(latents.shape[1] ,			dim=1		)
																						_UpperCamelCase     ,    _UpperCamelCase			     =     noise_pred.chunk(2		)
																						_UpperCamelCase     ,    _UpperCamelCase			     =     variance_pred.chunk(2		)
																						_UpperCamelCase			     =     noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																						_UpperCamelCase			     =     torch.cat([noise_pred, variance_pred_text] ,			dim=1		)

																	if not (
																	    hasattr(self.scheduler.config ,			'''variance_type'''		)
																	    and self.scheduler.config.variance_type in ["learned", "learned_range"]
																	):
																						_UpperCamelCase     ,    _UpperCamelCase			     =     noise_pred.split(latents.shape[1] ,			dim=1		)

																	# compute the previous noisy sample x_t -> x_t-1
																	_UpperCamelCase			     =     self.scheduler.step(
																	    __SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE ,			__SCREAMING_SNAKE_CASE ,			generator=__SCREAMING_SNAKE_CASE ,			).prev_sample
												# post-processing
												_UpperCamelCase			     =     self.movq.decode(__SCREAMING_SNAKE_CASE ,			force_not_quantize=__SCREAMING_SNAKE_CASE		)['''sample''']

												if output_type not in ["pt", "np", "pil"]:
																	raise ValueError(F"""Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}"""		)

												if output_type in ["np", "pil"]:
																	_UpperCamelCase			     =     image * 0.5 + 0.5
																	_UpperCamelCase			     =     image.clamp(0 ,			1		)
																	_UpperCamelCase			     =     image.cpu().permute(0 ,			2 ,			3 ,			1		).float().numpy()

												if output_type == "pil":
																	_UpperCamelCase			     =     self.numpy_to_pil(__SCREAMING_SNAKE_CASE		)

												if not return_dict:
																	return (image,)

												return ImagePipelineOutput(images=__SCREAMING_SNAKE_CASE		)



'''simple docstring'''



import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      LiltForQuestionAnswering,
      LiltForSequenceClassification,
      LiltForTokenClassification,
      LiltModel,
  )
  from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST







class 		lowerCAmelCase__  :



 """simple docstring"""



 def __init__(						self   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			str=13   ,				__SCREAMING_SNAKE_CASE   :			int=7   ,				__SCREAMING_SNAKE_CASE   :			List[str]=True   ,				__SCREAMING_SNAKE_CASE   :			Any=True   ,				__SCREAMING_SNAKE_CASE   :			str=True   ,				__SCREAMING_SNAKE_CASE   :			str=True   ,				__SCREAMING_SNAKE_CASE   :			Dict=99   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]=24   ,				__SCREAMING_SNAKE_CASE   :			Any=2   ,				__SCREAMING_SNAKE_CASE   :			Any=6   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]=37   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]="gelu"   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]=0.1   ,				__SCREAMING_SNAKE_CASE   :			List[Any]=0.1   ,				__SCREAMING_SNAKE_CASE   :			int=512   ,				__SCREAMING_SNAKE_CASE   :			str=16   ,				__SCREAMING_SNAKE_CASE   :			Any=2   ,				__SCREAMING_SNAKE_CASE   :			List[str]=0.02   ,				__SCREAMING_SNAKE_CASE   :			int=3   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]=None   ,				__SCREAMING_SNAKE_CASE   :			List[Any]=1_000   ,				)    ->					int:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = parent
      __SCREAMING_SNAKE_CASE      = batch_size
      __SCREAMING_SNAKE_CASE      = seq_length
      __SCREAMING_SNAKE_CASE      = is_training
      __SCREAMING_SNAKE_CASE      = use_input_mask
      __SCREAMING_SNAKE_CASE      = use_token_type_ids
      __SCREAMING_SNAKE_CASE      = use_labels
      __SCREAMING_SNAKE_CASE      = vocab_size
      __SCREAMING_SNAKE_CASE      = hidden_size
      __SCREAMING_SNAKE_CASE      = num_hidden_layers
      __SCREAMING_SNAKE_CASE      = num_attention_heads
      __SCREAMING_SNAKE_CASE      = intermediate_size
      __SCREAMING_SNAKE_CASE      = hidden_act
      __SCREAMING_SNAKE_CASE      = hidden_dropout_prob
      __SCREAMING_SNAKE_CASE      = attention_probs_dropout_prob
      __SCREAMING_SNAKE_CASE      = max_position_embeddings
      __SCREAMING_SNAKE_CASE      = type_vocab_size
      __SCREAMING_SNAKE_CASE      = type_sequence_label_size
      __SCREAMING_SNAKE_CASE      = initializer_range
      __SCREAMING_SNAKE_CASE      = num_labels
      __SCREAMING_SNAKE_CASE      = scope
      __SCREAMING_SNAKE_CASE      = range_bbox
 def  UpperCAmelCase__						(						self   :			Union[str, Any]     )    ->					Optional[int]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length]   ,				self.vocab_size     )

      __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length, 4]   ,				self.range_bbox     )
      # Ensure that bbox is legal
      for i in range(bbox.shape[0]     ):
           for j in range(bbox.shape[1]     ):
                if bbox[i, j, 3] < bbox[i, j, 1]:
                     __SCREAMING_SNAKE_CASE      = bbox[i, j, 3]
                     __SCREAMING_SNAKE_CASE      = bbox[i, j, 1]
                     __SCREAMING_SNAKE_CASE      = t
                if bbox[i, j, 2] < bbox[i, j, 0]:
                     __SCREAMING_SNAKE_CASE      = bbox[i, j, 2]
                     __SCREAMING_SNAKE_CASE      = bbox[i, j, 0]
                     __SCREAMING_SNAKE_CASE      = t

      __SCREAMING_SNAKE_CASE      = None
      if self.use_input_mask:
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length]   ,				vocab_size=2     )

      __SCREAMING_SNAKE_CASE      = None
      if self.use_token_type_ids:
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length]   ,				self.type_vocab_size     )

      __SCREAMING_SNAKE_CASE      = None
      __SCREAMING_SNAKE_CASE      = None
      if self.use_labels:
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size]   ,				self.type_sequence_label_size     )
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length]   ,				self.num_labels     )

      __SCREAMING_SNAKE_CASE      = self.get_config()

      return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels
 def  UpperCAmelCase__						(						self   :			str     )    ->					int:


      """simple docstring"""




      return LiltConfig(
          vocab_size=self.vocab_size   ,				hidden_size=self.hidden_size   ,				num_hidden_layers=self.num_hidden_layers   ,				num_attention_heads=self.num_attention_heads   ,				intermediate_size=self.intermediate_size   ,				hidden_act=self.hidden_act   ,				hidden_dropout_prob=self.hidden_dropout_prob   ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,				max_position_embeddings=self.max_position_embeddings   ,				type_vocab_size=self.type_vocab_size   ,				initializer_range=self.initializer_range   ,				)
 def  UpperCAmelCase__						(						self   :			int   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			int   ,				)    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltModel(config=__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				attention_mask=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE     )

      self.parent.assertEqual(result.last_hidden_state.shape   ,				(self.batch_size, self.seq_length, self.hidden_size)     )
      self.parent.assertEqual(result.pooler_output.shape   ,				(self.batch_size, self.hidden_size)     )
 def  UpperCAmelCase__						(						self   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				)    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.num_labels
      __SCREAMING_SNAKE_CASE      = LiltForTokenClassification(config=__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(
          __SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				attention_mask=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE   ,				labels=__SCREAMING_SNAKE_CASE     )
      self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.seq_length, self.num_labels)     )
 def  UpperCAmelCase__						(						self   :			int   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			Any   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				)    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltForQuestionAnswering(config=__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(
          __SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				attention_mask=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE   ,				start_positions=__SCREAMING_SNAKE_CASE   ,				end_positions=__SCREAMING_SNAKE_CASE   ,				)
      self.parent.assertEqual(result.start_logits.shape   ,				(self.batch_size, self.seq_length)     )
      self.parent.assertEqual(result.end_logits.shape   ,				(self.batch_size, self.seq_length)     )


 def  UpperCAmelCase__						(						self   :			Dict     )    ->					str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.prepare_config_and_inputs()
      (
          (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     
      )      = config_and_inputs
      __SCREAMING_SNAKE_CASE      = {
          """input_ids""": input_ids,
          """bbox""": bbox,
          """token_type_ids""": token_type_ids,
          """attention_mask""": input_mask,
      }
      return config, inputs_dict







@require_torch
class 		lowerCAmelCase__  ( a					,   a					,   a					,   unittest.TestCase   ):



 """simple docstring"""



 lowerCAmelCase__       = (
     (
         LiltModel,
         LiltForSequenceClassification,
         LiltForTokenClassification,
         LiltForQuestionAnswering,
     )
     if is_torch_available()
     else ()
 )
 lowerCAmelCase__       = (
     {
         "feature-extraction": LiltModel,
         "question-answering": LiltForQuestionAnswering,
         "text-classification": LiltForSequenceClassification,
         "token-classification": LiltForTokenClassification,
         "zero-shot": LiltForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 lowerCAmelCase__       = False
 lowerCAmelCase__       = False
 def  UpperCAmelCase__						(						self   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			Any   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			int     )    ->					str:


      """simple docstring"""




      return True
 def  UpperCAmelCase__						(						self   :			List[Any]     )    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltModelTester(self     )
      __SCREAMING_SNAKE_CASE      = ConfigTester(self   ,				config_class=__SCREAMING_SNAKE_CASE   ,				hidden_size=37     )
 def  UpperCAmelCase__						(						self   :			int     )    ->					Any:


      """simple docstring"""




      self.config_tester.run_common_tests()
 def  UpperCAmelCase__						(						self   :			Optional[Any]     )    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			List[str]     )    ->					Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
           __SCREAMING_SNAKE_CASE      = type
           self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			int     )    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Any     )    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE     )


 @slow
 def  UpperCAmelCase__						(						self   :			Dict     )    ->					int:


      """simple docstring"""




      for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           __SCREAMING_SNAKE_CASE      = LiltModel.from_pretrained(__SCREAMING_SNAKE_CASE     )
           self.assertIsNotNone(__SCREAMING_SNAKE_CASE     )







@require_torch
@slow
class 		lowerCAmelCase__  ( unittest.TestCase   ):



 """simple docstring"""



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


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltModel.from_pretrained("""SCUT-DLVCLab/lilt-roberta-en-base"""     ).to(__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = torch.tensor([[1, 2]]   ,				device=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]   ,				device=__SCREAMING_SNAKE_CASE     )

      # forward pass
      with torch.no_grad():
           __SCREAMING_SNAKE_CASE      = model(input_ids=__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = torch.Size([1, 2, 768]     )
      __SCREAMING_SNAKE_CASE      = torch.tensor(
          [[-0.0653, 0.0950, -0.0061], [-0.0545, 0.0926, -0.0324]]   ,				device=__SCREAMING_SNAKE_CASE   ,				)

      self.assertTrue(outputs.last_hidden_state.shape   ,				__SCREAMING_SNAKE_CASE     )
      self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3]   ,				__SCREAMING_SNAKE_CASE   ,				atol=1E-3     )     )






