


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   __lowercase				:





      def __init__(		self						:					List[str]					,       __lowerCamelCase						:					Optional[int]					,       __lowerCamelCase						:					Optional[int]=1_3					,       __lowerCamelCase						:					int=7					,       __lowerCamelCase						:					str=True					,       __lowerCamelCase						:					List[str]=True					,       __lowerCamelCase						:					Optional[Any]=True					,       __lowerCamelCase						:					List[str]=True					,       __lowerCamelCase						:					List[str]=9_9					,       __lowerCamelCase						:					Any=2_4					,       __lowerCamelCase						:					Union[str, Any]=2					,       __lowerCamelCase						:					List[Any]=6					,       __lowerCamelCase						:					str=3_7					,       __lowerCamelCase						:					List[Any]="gelu"					,       __lowerCamelCase						:					Any=0.1					,       __lowerCamelCase						:					Optional[Any]=0.1					,       __lowerCamelCase						:					str=5_1_2					,       __lowerCamelCase						:					Dict=1_6					,       __lowerCamelCase						:					int=2					,       __lowerCamelCase						:					Union[str, Any]=0.02					,       __lowerCamelCase						:					Any=3					,       __lowerCamelCase						:					int=None					,       __lowerCamelCase						:					Optional[int]=1_0_0_0					,       )    ->   List[Any]:






         """simple docstring"""







         UpperCAmelCase							=     parent
         UpperCAmelCase							=     batch_size
         UpperCAmelCase							=     seq_length
         UpperCAmelCase							=     is_training
         UpperCAmelCase							=     use_input_mask
         UpperCAmelCase							=     use_token_type_ids
         UpperCAmelCase							=     use_labels
         UpperCAmelCase							=     vocab_size
         UpperCAmelCase							=     hidden_size
         UpperCAmelCase							=     num_hidden_layers
         UpperCAmelCase							=     num_attention_heads
         UpperCAmelCase							=     intermediate_size
         UpperCAmelCase							=     hidden_act
         UpperCAmelCase							=     hidden_dropout_prob
         UpperCAmelCase							=     attention_probs_dropout_prob
         UpperCAmelCase							=     max_position_embeddings
         UpperCAmelCase							=     type_vocab_size
         UpperCAmelCase							=     type_sequence_label_size
         UpperCAmelCase							=     initializer_range
         UpperCAmelCase							=     num_labels
         UpperCAmelCase							=     scope
         UpperCAmelCase							=     range_bbox





      def        _lowercase				(		self						:					int       )    ->   List[Any]:






         """simple docstring"""







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

         UpperCAmelCase							=     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]:
                  UpperCAmelCase							=     bbox[i, j, 3]
                  UpperCAmelCase							=     bbox[i, j, 1]
                  UpperCAmelCase							=     t
               if bbox[i, j, 2] < bbox[i, j, 0]:
                  UpperCAmelCase							=     bbox[i, j, 2]
                  UpperCAmelCase							=     bbox[i, j, 0]
                  UpperCAmelCase							=     t

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

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

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

         UpperCAmelCase							=     self.get_config()

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





      def        _lowercase				(		self						:					Tuple       )    ->   Optional[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        _lowercase				(		self						:					Tuple					,       __lowerCamelCase						:					Union[str, Any]					,       __lowerCamelCase						:					Optional[int]					,       __lowerCamelCase						:					Optional[int]					,       __lowerCamelCase						:					int					,       __lowerCamelCase						:					Union[str, Any]					,       __lowerCamelCase						:					Union[str, Any]					,       __lowerCamelCase						:					List[Any]					,       )    ->   Optional[Any]:






         """simple docstring"""







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

         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        _lowercase				(		self						:					Union[str, Any]					,       __lowerCamelCase						:					Optional[Any]					,       __lowerCamelCase						:					str					,       __lowerCamelCase						:					List[Any]					,       __lowerCamelCase						:					str					,       __lowerCamelCase						:					Any					,       __lowerCamelCase						:					str					,       __lowerCamelCase						:					Optional[int]					,       )    ->   List[str]:






         """simple docstring"""







         UpperCAmelCase							=     self.num_labels
         UpperCAmelCase							=     LiltForTokenClassification(config=__lowerCamelCase       )
         model.to(__lowerCamelCase       )
         model.eval()
         UpperCAmelCase							=     model(
             __lowerCamelCase					,       bbox=__lowerCamelCase					,       attention_mask=__lowerCamelCase					,       token_type_ids=__lowerCamelCase					,       labels=__lowerCamelCase       )
         self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.seq_length, self.num_labels)       )





      def        _lowercase				(		self						:					Union[str, Any]					,       __lowerCamelCase						:					Tuple					,       __lowerCamelCase						:					Dict					,       __lowerCamelCase						:					Tuple					,       __lowerCamelCase						:					Tuple					,       __lowerCamelCase						:					Any					,       __lowerCamelCase						:					Dict					,       __lowerCamelCase						:					List[str]					,       )    ->   List[Any]:






         """simple docstring"""







         UpperCAmelCase							=     LiltForQuestionAnswering(config=__lowerCamelCase       )
         model.to(__lowerCamelCase       )
         model.eval()
         UpperCAmelCase							=     model(
             __lowerCamelCase					,       bbox=__lowerCamelCase					,       attention_mask=__lowerCamelCase					,       token_type_ids=__lowerCamelCase					,       start_positions=__lowerCamelCase					,       end_positions=__lowerCamelCase					,       )
         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        _lowercase				(		self						:					Tuple       )    ->   List[Any]:






         """simple docstring"""







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






@require_torch
class   __lowercase				(  __snake_case ,					__snake_case ,					__snake_case ,					unittest.TestCase  ):
      UpperCamelCase								=       (
          (
              LiltModel,
              LiltForSequenceClassification,
              LiltForTokenClassification,
              LiltForQuestionAnswering,
          )
          if is_torch_available()
          else ()
      )
      UpperCamelCase								=       (
          {
              '''feature-extraction''': LiltModel,
              '''question-answering''': LiltForQuestionAnswering,
              '''text-classification''': LiltForSequenceClassification,
              '''token-classification''': LiltForTokenClassification,
              '''zero-shot''': LiltForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      UpperCamelCase								=       False
      UpperCamelCase								=       False





      def        _lowercase				(		self						:					List[str]					,       __lowerCamelCase						:					Optional[Any]					,       __lowerCamelCase						:					List[str]					,       __lowerCamelCase						:					str					,       __lowerCamelCase						:					Union[str, Any]					,       __lowerCamelCase						:					Optional[Any]       )    ->   Dict:






         """simple docstring"""







         return True





      def        _lowercase				(		self						:					Dict       )    ->   str:






         """simple docstring"""







         UpperCAmelCase							=     LiltModelTester(self       )
         UpperCAmelCase							=     ConfigTester(self					,       config_class=__lowerCamelCase					,       hidden_size=3_7       )





      def        _lowercase				(		self						:					int       )    ->   List[Any]:






         """simple docstring"""







         self.config_tester.run_common_tests()





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






         """simple docstring"""







         UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__lowerCamelCase       )





      def        _lowercase				(		self						:					Dict       )    ->   Tuple:






         """simple docstring"""







         UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
            UpperCAmelCase							=     type
            self.model_tester.create_and_check_model(*__lowerCamelCase       )





      def        _lowercase				(		self						:					Tuple       )    ->   Dict:






         """simple docstring"""







         UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase       )





      def        _lowercase				(		self						:					List[str]       )    ->   Dict:






         """simple docstring"""







         UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*__lowerCamelCase       )





      @slow
      def        _lowercase				(		self						:					Optional[int]       )    ->   Dict:






         """simple docstring"""







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






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





      def        _lowercase				(		self						:					Any       )    ->   int:






         """simple docstring"""







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

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

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

         UpperCAmelCase							=     torch.Size([1, 2, 7_6_8]       )
         UpperCAmelCase							=     torch.tensor(
             [[-0.0_653, 0.0_950, -0.0_061], [-0.0_545, 0.0_926, -0.0_324]]					,       device=__lowerCamelCase					,       )

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







from math import isqrt
def   _UpperCamelCase				(						lowerCAmelCase_   )						->bool:
   return all(number % divisor != 0 for divisor in range(2  ,						isqrt(lowerCAmelCase_   ) + 1   )   )
def   _UpperCamelCase				(						lowerCAmelCase_ = 1_0**6   )						->int:
   UpperCAmelCase							=     0
   UpperCAmelCase							=     1
   UpperCAmelCase							=     7
   while prime_candidate < max_prime:
      primes_count += is_prime(lowerCAmelCase_   )

      cube_index += 1
      prime_candidate += 6 * cube_index

   return primes_count


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



