





import tempfile

import torch

from diffusers import PNDMScheduler

from .test_schedulers import SchedulerCommonTest





class 					A_					(   UpperCAmelCase						):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_   :			List[str]  			=	(PNDMScheduler,)
       SCREAMING_SNAKE_CASE_   :			List[str]  			=	(('''num_inference_steps''', 5_0),)







       def  __UpperCAmelCase			(     self						:						Optional[int]    ,**__A						:						Any	)    ->       Optional[Any]:
         _lowercase						    =			{
             'num_train_timesteps': 1000,
             'beta_start': 0.0001,
             'beta_end': 0.02,
             'beta_schedule': 'linear',
         }

         config.update(**__A	)
         return config







       def  __UpperCAmelCase			(     self						:						List[str]    ,__A						:						Optional[Any]=0    ,**__A						:						Optional[int]	)    ->       List[Any]:
         _lowercase						    =			dict(self.forward_default_kwargs	)
         _lowercase						    =			kwargs.pop('num_inference_steps'    ,__A	)
         _lowercase						    =			self.dummy_sample
         _lowercase						    =			0.1 * sample
         _lowercase						    =			[residual + 0.2, residual + 0.15, residual + 0.1, residual + 0.05]

         for scheduler_class in self.scheduler_classes:
           _lowercase						    =			self.get_scheduler_config(**__A	)
           _lowercase						    =			scheduler_class(**__A	)
           scheduler.set_timesteps(__A	)
           # copy over dummy past residuals
           _lowercase						    =			dummy_past_residuals[:]

           with tempfile.TemporaryDirectory() as tmpdirname:
             scheduler.save_config(__A	)
             _lowercase						    =			scheduler_class.from_pretrained(__A	)
             new_scheduler.set_timesteps(__A	)
             # copy over dummy past residuals
             _lowercase						    =			dummy_past_residuals[:]

           _lowercase						    =			scheduler.step_prk(__A    ,__A    ,__A    ,**__A	).prev_sample
           _lowercase						    =			new_scheduler.step_prk(__A    ,__A    ,__A    ,**__A	).prev_sample

           assert torch.sum(torch.abs(output - new_output	)	) < 1e-5, "Scheduler outputs are not identical"

           _lowercase						    =			scheduler.step_plms(__A    ,__A    ,__A    ,**__A	).prev_sample
           _lowercase						    =			new_scheduler.step_plms(__A    ,__A    ,__A    ,**__A	).prev_sample

           assert torch.sum(torch.abs(output - new_output	)	) < 1e-5, "Scheduler outputs are not identical"







       def  __UpperCAmelCase			(     self						:						List[Any]	)    ->       Union[str, Any]:
         pass







       def  __UpperCAmelCase			(     self						:						Optional[int]    ,__A						:						Any=0    ,**__A						:						int	)    ->       Union[str, Any]:
         _lowercase						    =			dict(self.forward_default_kwargs	)
         _lowercase						    =			kwargs.pop('num_inference_steps'    ,__A	)
         _lowercase						    =			self.dummy_sample
         _lowercase						    =			0.1 * sample
         _lowercase						    =			[residual + 0.2, residual + 0.15, residual + 0.1, residual + 0.05]

         for scheduler_class in self.scheduler_classes:
           _lowercase						    =			self.get_scheduler_config()
           _lowercase						    =			scheduler_class(**__A	)
           scheduler.set_timesteps(__A	)

           # copy over dummy past residuals (must be after setting timesteps)
           _lowercase						    =			dummy_past_residuals[:]

           with tempfile.TemporaryDirectory() as tmpdirname:
             scheduler.save_config(__A	)
             _lowercase						    =			scheduler_class.from_pretrained(__A	)
             # copy over dummy past residuals
             new_scheduler.set_timesteps(__A	)

             # copy over dummy past residual (must be after setting timesteps)
             _lowercase						    =			dummy_past_residuals[:]

           _lowercase						    =			scheduler.step_prk(__A    ,__A    ,__A    ,**__A	).prev_sample
           _lowercase						    =			new_scheduler.step_prk(__A    ,__A    ,__A    ,**__A	).prev_sample

           assert torch.sum(torch.abs(output - new_output	)	) < 1e-5, "Scheduler outputs are not identical"

           _lowercase						    =			scheduler.step_plms(__A    ,__A    ,__A    ,**__A	).prev_sample
           _lowercase						    =			new_scheduler.step_plms(__A    ,__A    ,__A    ,**__A	).prev_sample

           assert torch.sum(torch.abs(output - new_output	)	) < 1e-5, "Scheduler outputs are not identical"







       def  __UpperCAmelCase			(     self						:						Any    ,**__A						:						Tuple	)    ->       List[Any]:
         _lowercase						    =			self.scheduler_classes[0]
         _lowercase						    =			self.get_scheduler_config(**__A	)
         _lowercase						    =			scheduler_class(**__A	)

         _lowercase						    =			10
         _lowercase						    =			self.dummy_model()
         _lowercase						    =			self.dummy_sample_deter
         scheduler.set_timesteps(__A	)

         for i, t in enumerate(scheduler.prk_timesteps	):
           _lowercase						    =			model(__A    ,__A	)
           _lowercase						    =			scheduler.step_prk(__A    ,__A    ,__A	).prev_sample

         for i, t in enumerate(scheduler.plms_timesteps	):
           _lowercase						    =			model(__A    ,__A	)
           _lowercase						    =			scheduler.step_plms(__A    ,__A    ,__A	).prev_sample

         return sample







       def  __UpperCAmelCase			(     self						:						Tuple	)    ->       Tuple:
         _lowercase						    =			dict(self.forward_default_kwargs	)

         _lowercase						    =			kwargs.pop('num_inference_steps'    ,__A	)

         for scheduler_class in self.scheduler_classes:
           _lowercase						    =			self.get_scheduler_config()
           _lowercase						    =			scheduler_class(**__A	)

           _lowercase						    =			self.dummy_sample
           _lowercase						    =			0.1 * sample

           if num_inference_steps is not None and hasattr(__A    ,'set_timesteps'	):
             scheduler.set_timesteps(__A	)
           elif num_inference_steps is not None and not hasattr(__A    ,'set_timesteps'	):
             _lowercase						    =			num_inference_steps

           # copy over dummy past residuals (must be done after set_timesteps)
           _lowercase						    =			[residual + 0.2, residual + 0.15, residual + 0.1, residual + 0.05]
           _lowercase						    =			dummy_past_residuals[:]

           _lowercase						    =			scheduler.step_prk(__A    ,0    ,__A    ,**__A	).prev_sample
           _lowercase						    =			scheduler.step_prk(__A    ,1    ,__A    ,**__A	).prev_sample

           self.assertEqual(output_a.shape    ,sample.shape	)
           self.assertEqual(output_a.shape    ,output_a.shape	)

           _lowercase						    =			scheduler.step_plms(__A    ,0    ,__A    ,**__A	).prev_sample
           _lowercase						    =			scheduler.step_plms(__A    ,1    ,__A    ,**__A	).prev_sample

           self.assertEqual(output_a.shape    ,sample.shape	)
           self.assertEqual(output_a.shape    ,output_a.shape	)







       def  __UpperCAmelCase			(     self						:						Dict	)    ->       Union[str, Any]:
         for timesteps in [100, 1000]:
           self.check_over_configs(num_train_timesteps=__A	)







       def  __UpperCAmelCase			(     self						:						Any	)    ->       Optional[int]:
         for steps_offset in [0, 1]:
           self.check_over_configs(steps_offset=__A	)

         _lowercase						    =			self.scheduler_classes[0]
         _lowercase						    =			self.get_scheduler_config(steps_offset=1	)
         _lowercase						    =			scheduler_class(**__A	)
         scheduler.set_timesteps(10	)
         assert torch.equal(
             scheduler.timesteps    ,torch.LongTensor(
                 [901, 851, 851, 801, 801, 751, 751, 701, 701, 651, 651, 601, 601, 501, 401, 301, 201, 101, 1]	)    ,)







       def  __UpperCAmelCase			(     self						:						str	)    ->       Dict:
         for beta_start, beta_end in zip([0.0001, 0.001]    ,[0.002, 0.02]	):
           self.check_over_configs(beta_start=__A    ,beta_end=__A	)







       def  __UpperCAmelCase			(     self						:						str	)    ->       Union[str, Any]:
         for schedule in ["linear", "squaredcos_cap_v2"]:
           self.check_over_configs(beta_schedule=__A	)







       def  __UpperCAmelCase			(     self						:						Dict	)    ->       Optional[int]:
         for prediction_type in ["epsilon", "v_prediction"]:
           self.check_over_configs(prediction_type=__A	)







       def  __UpperCAmelCase			(     self						:						Optional[int]	)    ->       int:
         for t in [1, 5, 10]:
           self.check_over_forward(time_step=__A	)







       def  __UpperCAmelCase			(     self						:						str	)    ->       Optional[int]:
         for t, num_inference_steps in zip([1, 5, 10]    ,[10, 50, 100]	):
           self.check_over_forward(num_inference_steps=__A	)







       def  __UpperCAmelCase			(     self						:						Dict	)    ->       List[Any]:
         # earlier version of set_timesteps() caused an error indexing alpha's with inference steps as power of 3
         _lowercase						    =			27

         for scheduler_class in self.scheduler_classes:
           _lowercase						    =			self.dummy_sample
           _lowercase						    =			0.1 * sample

           _lowercase						    =			self.get_scheduler_config()
           _lowercase						    =			scheduler_class(**__A	)

           scheduler.set_timesteps(__A	)

           # before power of 3 fix, would error on first step, so we only need to do two
           for i, t in enumerate(scheduler.prk_timesteps[:2]	):
             _lowercase						    =			scheduler.step_prk(__A    ,__A    ,__A	).prev_sample







       def  __UpperCAmelCase			(     self						:						List[Any]	)    ->       List[str]:
         with self.assertRaises(__A	):
           _lowercase						    =			self.scheduler_classes[0]
           _lowercase						    =			self.get_scheduler_config()
           _lowercase						    =			scheduler_class(**__A	)

           scheduler.step_plms(self.dummy_sample    ,1    ,self.dummy_sample	).prev_sample







       def  __UpperCAmelCase			(     self						:						Union[str, Any]	)    ->       Union[str, Any]:
         _lowercase						    =			self.full_loop()
         _lowercase						    =			torch.sum(torch.abs(__A	)	)
         _lowercase						    =			torch.mean(torch.abs(__A	)	)

         assert abs(result_sum.item() - 198.1318	) < 1e-2
         assert abs(result_mean.item() - 0.2580	) < 1e-3







       def  __UpperCAmelCase			(     self						:						Optional[Any]	)    ->       List[str]:
         _lowercase						    =			self.full_loop(prediction_type='v_prediction'	)
         _lowercase						    =			torch.sum(torch.abs(__A	)	)
         _lowercase						    =			torch.mean(torch.abs(__A	)	)

         assert abs(result_sum.item() - 67.3986	) < 1e-2
         assert abs(result_mean.item() - 0.0878	) < 1e-3







       def  __UpperCAmelCase			(     self						:						Optional[Any]	)    ->       Dict:
         # We specify different beta, so that the first alpha is 0.99
         _lowercase						    =			self.full_loop(set_alpha_to_one=__A    ,beta_start=0.01	)
         _lowercase						    =			torch.sum(torch.abs(__A	)	)
         _lowercase						    =			torch.mean(torch.abs(__A	)	)

         assert abs(result_sum.item() - 230.0399	) < 1e-2
         assert abs(result_mean.item() - 0.2995	) < 1e-3







       def  __UpperCAmelCase			(     self						:						Optional[Any]	)    ->       List[Any]:
         # We specify different beta, so that the first alpha is 0.99
         _lowercase						    =			self.full_loop(set_alpha_to_one=__A    ,beta_start=0.01	)
         _lowercase						    =			torch.sum(torch.abs(__A	)	)
         _lowercase						    =			torch.mean(torch.abs(__A	)	)

         assert abs(result_sum.item() - 186.9482	) < 1e-2
         assert abs(result_mean.item() - 0.2434	) < 1e-3


'''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     )     )






