




'''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 				_a							:





       '''simple docstring'''






       def __init__(	self,				A,				A=13,				A=7,				A=True,				A=True,				A=True,				A=True,				A=99,				A=24,				A=2,				A=6,				A=37,				A="gelu",				A=0.1,				A=0.1,				A=512,				A=16,				A=2,				A=0.02,				A=3,				A=None,				A=1_000,				):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		parent
             SCREAMING_SNAKE_CASE					:	List[Any]   =		batch_size
             SCREAMING_SNAKE_CASE					:	Dict   =		seq_length
             SCREAMING_SNAKE_CASE					:	Tuple   =		is_training
             SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		use_input_mask
             SCREAMING_SNAKE_CASE					:	Tuple   =		use_token_type_ids
             SCREAMING_SNAKE_CASE					:	Optional[Any]   =		use_labels
             SCREAMING_SNAKE_CASE					:	str   =		vocab_size
             SCREAMING_SNAKE_CASE					:	Optional[int]   =		hidden_size
             SCREAMING_SNAKE_CASE					:	Any   =		num_hidden_layers
             SCREAMING_SNAKE_CASE					:	Optional[Any]   =		num_attention_heads
             SCREAMING_SNAKE_CASE					:	Optional[Any]   =		intermediate_size
             SCREAMING_SNAKE_CASE					:	Optional[Any]   =		hidden_act
             SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		hidden_dropout_prob
             SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		attention_probs_dropout_prob
             SCREAMING_SNAKE_CASE					:	List[Any]   =		max_position_embeddings
             SCREAMING_SNAKE_CASE					:	str   =		type_vocab_size
             SCREAMING_SNAKE_CASE					:	Optional[int]   =		type_sequence_label_size
             SCREAMING_SNAKE_CASE					:	Dict   =		initializer_range
             SCREAMING_SNAKE_CASE					:	int   =		num_labels
             SCREAMING_SNAKE_CASE					:	Optional[int]   =		scope
             SCREAMING_SNAKE_CASE					:	int   =		range_bbox







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	int   =		ids_tensor([self.batch_size, self.seq_length],				self.vocab_size   )

             SCREAMING_SNAKE_CASE					:	Any   =		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					:	Union[str, Any]   =		bbox[i, j, 3]
                               SCREAMING_SNAKE_CASE					:	int   =		bbox[i, j, 1]
                               SCREAMING_SNAKE_CASE					:	int   =		t
                         if bbox[i, j, 2] < bbox[i, j, 0]:
                               SCREAMING_SNAKE_CASE					:	List[str]   =		bbox[i, j, 2]
                               SCREAMING_SNAKE_CASE					:	Optional[int]   =		bbox[i, j, 0]
                               SCREAMING_SNAKE_CASE					:	Optional[Any]   =		t

             SCREAMING_SNAKE_CASE					:	Dict   =		None
             if self.use_input_mask:
                   SCREAMING_SNAKE_CASE					:	Optional[int]   =		ids_tensor([self.batch_size, self.seq_length],				vocab_size=2   )

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

             SCREAMING_SNAKE_CASE					:	Dict   =		None
             SCREAMING_SNAKE_CASE					:	int   =		None
             if self.use_labels:
                   SCREAMING_SNAKE_CASE					:	List[Any]   =		ids_tensor([self.batch_size],				self.type_sequence_label_size   )
                   SCREAMING_SNAKE_CASE					:	int   =		ids_tensor([self.batch_size, self.seq_length],				self.num_labels   )

             SCREAMING_SNAKE_CASE					:	List[Any]   =		self.get_config()

             return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels







       def     UpperCamelCase_				(	self   ):







             '''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,				A,				A,				A,				A,				A,				A,				A,				):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Any   =		LiltModel(config=A_   )
             model.to(A_   )
             model.eval()
             SCREAMING_SNAKE_CASE					:	str   =		model(A_,				bbox=A_,				attention_mask=A_,				token_type_ids=A_   )
             SCREAMING_SNAKE_CASE					:	Optional[int]   =		model(A_,				bbox=A_,				token_type_ids=A_   )
             SCREAMING_SNAKE_CASE					:	Any   =		model(A_,				bbox=A_   )

             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,				A,				A,				A,				A,				A,				A,				A,				):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Any   =		self.num_labels
             SCREAMING_SNAKE_CASE					:	Dict   =		LiltForTokenClassification(config=A_   )
             model.to(A_   )
             model.eval()
             SCREAMING_SNAKE_CASE					:	Dict   =		model(
                 A_,				bbox=A_,				attention_mask=A_,				token_type_ids=A_,				labels=A_   )
             self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length, self.num_labels)   )







       def     UpperCamelCase_				(	self,				A,				A,				A,				A,				A,				A,				A,				):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Dict   =		LiltForQuestionAnswering(config=A_   )
             model.to(A_   )
             model.eval()
             SCREAMING_SNAKE_CASE					:	List[str]   =		model(
                 A_,				bbox=A_,				attention_mask=A_,				token_type_ids=A_,				start_positions=A_,				end_positions=A_,				)
             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   ):







             '''simple docstring'''







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






@require_torch
class 				_a							(       __snake_case      ,	__snake_case      ,	__snake_case      ,	unittest.TestCase      ):





       '''simple docstring'''






       A		:							Union[str, Any]								=		(
           (
               LiltModel,
               LiltForSequenceClassification,
               LiltForTokenClassification,
               LiltForQuestionAnswering,
           )
           if is_torch_available()
           else ()
       )
       A		:							Optional[Any]								=		(
           {
               'feature-extraction': LiltModel,
               'question-answering': LiltForQuestionAnswering,
               'text-classification': LiltForSequenceClassification,
               'token-classification': LiltForTokenClassification,
               'zero-shot': LiltForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       A		:							Dict								=		False
       A		:							Union[str, Any]								=		False







       def     UpperCamelCase_				(	self,				A,				A,				A,				A,				A   ):







             '''simple docstring'''







             return True







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Optional[int]   =		LiltModelTester(self   )
             SCREAMING_SNAKE_CASE					:	Optional[int]   =		ConfigTester(self,				config_class=A_,				hidden_size=37   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             self.config_tester.run_common_tests()







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Tuple   =		self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*A_   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Tuple   =		self.model_tester.prepare_config_and_inputs()
             for type in ["absolute", "relative_key", "relative_key_query"]:
                   SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		type
                   self.model_tester.create_and_check_model(*A_   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	int   =		self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_token_classification(*A_   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	List[Any]   =		self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_question_answering(*A_   )







       @slow
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







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






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





       '''simple docstring'''






       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	int   =		LiltModel.from_pretrained('SCUT-DLVCLab/lilt-roberta-en-base'   ).to(A_   )

             SCREAMING_SNAKE_CASE					:	Tuple   =		torch.tensor([[1, 2]],				device=A_   )
             SCREAMING_SNAKE_CASE					:	List[str]   =		torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]],				device=A_   )

             # forward pass
             with torch.no_grad():
                   SCREAMING_SNAKE_CASE					:	Optional[int]   =		model(input_ids=A_,				bbox=A_   )

             SCREAMING_SNAKE_CASE					:	List[str]   =		torch.Size([1, 2, 768]   )
             SCREAMING_SNAKE_CASE					:	Any   =		torch.tensor(
                 [[-0.06_53, 0.09_50, -0.00_61], [-0.05_45, 0.09_26, -0.03_24]],				device=A_,				)

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









def 		A_				(     _lowerCAmelCase = 50     )						-> int:
 UpperCamelCase	:					List[Any]       	=   [[0] * 3 for _ in range(length + 1     )]

 for row_length in range(length + 1     ):
  for tile_length in range(2							,   5     ):
   for tile_start in range(row_length - tile_length + 1     ):
    different_colour_ways_number[row_length][tile_length - 2] += (
        different_colour_ways_number[row_length - tile_start - tile_length][
            tile_length - 2
        ]
        + 1
    )

 return sum(different_colour_ways_number[length]     )


if __name__ == "__main__":
    print(f"""{solution() = }""")
