

'''simple docstring'''






import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
     MODEL_FOR_QUESTION_ANSWERING_MAPPING,
     MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
     MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
     LayoutLMvaConfig,
     LayoutLMvaForQuestionAnswering,
     LayoutLMvaForSequenceClassification,
     LayoutLMvaForTokenClassification,
     LayoutLMvaModel,
 )
 from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
 from PIL import Image

 from transformers import LayoutLMvaImageProcessor






class 			lowercase_	:




  """simple docstring"""




  def __init__(      self   :     str					,lowercase__   :     Any					,lowercase__   :     Optional[Any]=2					,lowercase__   :     List[Any]=3					,lowercase__   :     Any=4					,lowercase__   :     Optional[Any]=2					,lowercase__   :     Union[str, Any]=7					,lowercase__   :     Optional[int]=True					,lowercase__   :     str=True					,lowercase__   :     List[Any]=True					,lowercase__   :     Optional[Any]=True					,lowercase__   :     Optional[Any]=9_9					,lowercase__   :     List[str]=3_6					,lowercase__   :     str=3					,lowercase__   :     int=4					,lowercase__   :     int=3_7					,lowercase__   :     str="gelu"					,lowercase__   :     Optional[int]=0.1					,lowercase__   :     str=0.1					,lowercase__   :     Optional[int]=5_1_2					,lowercase__   :     List[Any]=1_6					,lowercase__   :     int=2					,lowercase__   :     Tuple=0.0_2					,lowercase__   :     List[str]=6					,lowercase__   :     str=6					,lowercase__   :     str=3					,lowercase__   :     List[str]=4					,lowercase__   :     Optional[Any]=None					,lowercase__   :     Any=1_0_0_0					,):
   __lowercase							  = parent
   __lowercase							  = batch_size
   __lowercase							  = num_channels
   __lowercase							  = image_size
   __lowercase							  = patch_size
   __lowercase							  = text_seq_length
   __lowercase							  = is_training
   __lowercase							  = use_input_mask
   __lowercase							  = use_token_type_ids
   __lowercase							  = use_labels
   __lowercase							  = vocab_size
   __lowercase							  = hidden_size
   __lowercase							  = num_hidden_layers
   __lowercase							  = num_attention_heads
   __lowercase							  = intermediate_size
   __lowercase							  = hidden_act
   __lowercase							  = hidden_dropout_prob
   __lowercase							  = attention_probs_dropout_prob
   __lowercase							  = max_position_embeddings
   __lowercase							  = type_vocab_size
   __lowercase							  = type_sequence_label_size
   __lowercase							  = initializer_range
   __lowercase							  = coordinate_size
   __lowercase							  = shape_size
   __lowercase							  = num_labels
   __lowercase							  = num_choices
   __lowercase							  = scope
   __lowercase							  = range_bbox

   # LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
   __lowercase							  = text_seq_length
   __lowercase							  = (image_size // patch_size) ** 2 + 1
   __lowercase							  = self.text_seq_length + self.image_seq_length






  def 					SCREAMING_SNAKE_CASE      (      self   :     int			):
   __lowercase							  = ids_tensor([self.batch_size, self.text_seq_length]					,self.vocab_size			)

   __lowercase							  = ids_tensor([self.batch_size, self.text_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]:
      __lowercase							  = bbox[i, j, 3]
      __lowercase							  = bbox[i, j, 1]
      __lowercase							  = t
     if bbox[i, j, 2] < bbox[i, j, 0]:
      __lowercase							  = bbox[i, j, 2]
      __lowercase							  = bbox[i, j, 0]
      __lowercase							  = t

   __lowercase							  = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

   __lowercase							  = None
   if self.use_input_mask:
    __lowercase							  = random_attention_mask([self.batch_size, self.text_seq_length]			)

   __lowercase							  = None
   if self.use_token_type_ids:
    __lowercase							  = ids_tensor([self.batch_size, self.text_seq_length]					,self.type_vocab_size			)

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

   __lowercase							  = LayoutLMvaConfig(
       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					,coordinate_size=self.coordinate_size					,shape_size=self.shape_size					,input_size=self.image_size					,patch_size=self.patch_size					,)

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






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple					,lowercase__   :     List[str]					,lowercase__   :     Dict					,lowercase__   :     Tuple					,lowercase__   :     Tuple					,lowercase__   :     Dict					,lowercase__   :     int					,lowercase__   :     Optional[int]					,lowercase__   :     Dict			):
   __lowercase							  = LayoutLMvaModel(config=_UpperCamelCase			)
   model.to(_UpperCamelCase			)
   model.eval()

   # text + image
   __lowercase							  = model(_UpperCamelCase					,pixel_values=_UpperCamelCase			)
   __lowercase							  = model(
       _UpperCamelCase					,bbox=_UpperCamelCase					,pixel_values=_UpperCamelCase					,attention_mask=_UpperCamelCase					,token_type_ids=_UpperCamelCase			)
   __lowercase							  = model(_UpperCamelCase					,bbox=_UpperCamelCase					,pixel_values=_UpperCamelCase					,token_type_ids=_UpperCamelCase			)
   __lowercase							  = model(_UpperCamelCase					,bbox=_UpperCamelCase					,pixel_values=_UpperCamelCase			)

   self.parent.assertEqual(result.last_hidden_state.shape					,(self.batch_size, self.seq_length, self.hidden_size)			)

   # text only
   __lowercase							  = model(_UpperCamelCase			)
   self.parent.assertEqual(
       result.last_hidden_state.shape					,(self.batch_size, self.text_seq_length, self.hidden_size)			)

   # image only
   __lowercase							  = model(pixel_values=_UpperCamelCase			)
   self.parent.assertEqual(
       result.last_hidden_state.shape					,(self.batch_size, self.image_seq_length, self.hidden_size)			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Any					,lowercase__   :     List[str]					,lowercase__   :     Union[str, Any]					,lowercase__   :     Union[str, Any]					,lowercase__   :     Dict					,lowercase__   :     int					,lowercase__   :     Optional[Any]					,lowercase__   :     Tuple					,lowercase__   :     Optional[int]			):
   __lowercase							  = self.num_labels
   __lowercase							  = LayoutLMvaForSequenceClassification(_UpperCamelCase			)
   model.to(_UpperCamelCase			)
   model.eval()
   __lowercase							  = model(
       _UpperCamelCase					,bbox=_UpperCamelCase					,pixel_values=_UpperCamelCase					,attention_mask=_UpperCamelCase					,token_type_ids=_UpperCamelCase					,labels=_UpperCamelCase					,)
   self.parent.assertEqual(result.logits.shape					,(self.batch_size, self.num_labels)			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     int					,lowercase__   :     str					,lowercase__   :     List[str]					,lowercase__   :     Optional[int]					,lowercase__   :     Optional[int]					,lowercase__   :     Union[str, Any]					,lowercase__   :     Optional[Any]					,lowercase__   :     Optional[int]					,lowercase__   :     Optional[int]			):
   __lowercase							  = self.num_labels
   __lowercase							  = LayoutLMvaForTokenClassification(config=_UpperCamelCase			)
   model.to(_UpperCamelCase			)
   model.eval()
   __lowercase							  = model(
       _UpperCamelCase					,bbox=_UpperCamelCase					,pixel_values=_UpperCamelCase					,attention_mask=_UpperCamelCase					,token_type_ids=_UpperCamelCase					,labels=_UpperCamelCase					,)
   self.parent.assertEqual(result.logits.shape					,(self.batch_size, self.text_seq_length, self.num_labels)			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple					,lowercase__   :     Optional[Any]					,lowercase__   :     List[Any]					,lowercase__   :     Optional[int]					,lowercase__   :     Tuple					,lowercase__   :     str					,lowercase__   :     str					,lowercase__   :     Tuple					,lowercase__   :     Any			):
   __lowercase							  = LayoutLMvaForQuestionAnswering(config=_UpperCamelCase			)
   model.to(_UpperCamelCase			)
   model.eval()
   __lowercase							  = model(
       _UpperCamelCase					,bbox=_UpperCamelCase					,pixel_values=_UpperCamelCase					,attention_mask=_UpperCamelCase					,token_type_ids=_UpperCamelCase					,start_positions=_UpperCamelCase					,end_positions=_UpperCamelCase					,)
   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 					SCREAMING_SNAKE_CASE      (      self   :     List[Any]			):
   __lowercase							  = self.prepare_config_and_inputs()
   (
       (
       __lowercase						
   )  ,	(
       __lowercase						
   )  ,	(
       __lowercase						
   )  ,	(
       __lowercase						
   )  ,	(
       __lowercase						
   )  ,	(
       __lowercase						
   )  ,	(
       __lowercase						
   )  ,	(
       __lowercase						
   )  ,							
   )							  = config_and_inputs
   __lowercase							  = {
       '''input_ids''': input_ids,
       '''bbox''': bbox,
       '''pixel_values''': pixel_values,
       '''token_type_ids''': token_type_ids,
       '''attention_mask''': input_mask,
   }
   return config, inputs_dict






@require_torch
class 			lowercase_	(_lowerCamelCase				,       _lowerCamelCase				,       unittest.TestCase      ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE    :  Any							=			False
  SCREAMING_SNAKE_CASE    :  List[Any]							=			False
  SCREAMING_SNAKE_CASE    :  Optional[int]							=			False

  SCREAMING_SNAKE_CASE    :  Optional[Any]							=			(
      (
          LayoutLMvaModel,
          LayoutLMvaForSequenceClassification,
          LayoutLMvaForTokenClassification,
          LayoutLMvaForQuestionAnswering,
      )
      if is_torch_available()
      else ()
  )
  SCREAMING_SNAKE_CASE    :  Any							=			(
      {'document-question-answering': LayoutLMvaForQuestionAnswering, 'feature-extraction': LayoutLMvaModel}
      if is_torch_available()
      else {}
  )






  def 					SCREAMING_SNAKE_CASE      (      self   :     Union[str, Any]					,lowercase__   :     Optional[Any]					,lowercase__   :     Union[str, Any]					,lowercase__   :     Any					,lowercase__   :     Optional[Any]					,lowercase__   :     Tuple			):
   # `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
   # embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
   # the sequence dimension of the text embedding only.
   # (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
   return True






  def 					SCREAMING_SNAKE_CASE      (      self   :     List[str]			):
   __lowercase							  = LayoutLMvaModelTester(self			)
   __lowercase							  = ConfigTester(self					,config_class=_UpperCamelCase					,hidden_size=3_7			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict					,lowercase__   :     str					,lowercase__   :     int					,lowercase__   :     Dict=False			):
   __lowercase							  = copy.deepcopy(_UpperCamelCase			)
   if model_class in get_values(_UpperCamelCase			):
    __lowercase							  = {
        k: v.unsqueeze(1			).expand(-1					,self.model_tester.num_choices					,-1			).contiguous()
        if isinstance(_UpperCamelCase					,torch.Tensor			) and v.ndim > 1
        else v
        for k, v in inputs_dict.items()
    }
   if return_labels:
    if model_class in get_values(_UpperCamelCase			):
     __lowercase							  = torch.ones(self.model_tester.batch_size					,dtype=torch.long					,device=_UpperCamelCase			)
    elif model_class in get_values(_UpperCamelCase			):
     __lowercase							  = torch.zeros(
         self.model_tester.batch_size					,dtype=torch.long					,device=_UpperCamelCase			)
     __lowercase							  = torch.zeros(
         self.model_tester.batch_size					,dtype=torch.long					,device=_UpperCamelCase			)
    elif model_class in [
        *get_values(_UpperCamelCase			),
    ]:
     __lowercase							  = torch.zeros(
         self.model_tester.batch_size					,dtype=torch.long					,device=_UpperCamelCase			)
    elif model_class in [
        *get_values(_UpperCamelCase			),
    ]:
     __lowercase							  = torch.zeros(
         (self.model_tester.batch_size, self.model_tester.text_seq_length)					,dtype=torch.long					,device=_UpperCamelCase					,)

   return inputs_dict






  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict			):
   self.config_tester.run_common_tests()






  def 					SCREAMING_SNAKE_CASE      (      self   :     Any			):
   __lowercase							  = self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*_UpperCamelCase			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[Any]			):
   __lowercase							  = self.model_tester.prepare_config_and_inputs()
   for type in ["absolute", "relative_key", "relative_key_query"]:
    __lowercase							  = type
    self.model_tester.create_and_check_model(*_UpperCamelCase			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     List[Any]			):
   __lowercase							  = self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_sequence_classification(*_UpperCamelCase			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple			):
   __lowercase							  = self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[Any]			):
   __lowercase							  = self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase			)






  @slow
  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[Any]			):
   for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    __lowercase							  = LayoutLMvaModel.from_pretrained(_UpperCamelCase			)
    self.assertIsNotNone(_UpperCamelCase			)


def 		_A     (    ):






 """simple docstring"""



 __lowercase							  = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
 return image






@require_torch
class 			lowercase_	(unittest.TestCase      ):




  """simple docstring"""




  @cached_property
  def 					SCREAMING_SNAKE_CASE      (      self   :     List[Any]			):
   return LayoutLMvaImageProcessor(apply_ocr=_UpperCamelCase			) if is_vision_available() else None






  @slow
  def 					SCREAMING_SNAKE_CASE      (      self   :     List[str]			):
   __lowercase							  = LayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base'''			).to(_UpperCamelCase			)

   __lowercase							  = self.default_image_processor
   __lowercase							  = prepare_img()
   __lowercase							  = image_processor(images=_UpperCamelCase					,return_tensors='''pt'''			).pixel_values.to(_UpperCamelCase			)

   __lowercase							  = torch.tensor([[1, 2]]			)
   __lowercase							  = torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]			).unsqueeze(0			)

   # forward pass
   __lowercase							  = model(
       input_ids=input_ids.to(_UpperCamelCase			)					,bbox=bbox.to(_UpperCamelCase			)					,pixel_values=pixel_values.to(_UpperCamelCase			)					,)

   # verify the logits
   __lowercase							  = torch.Size((1, 1_9_9, 7_6_8)			)
   self.assertEqual(outputs.last_hidden_state.shape					,_UpperCamelCase			)

   __lowercase							  = torch.tensor(
       [[-0.0_5_2_9, 0.3_6_1_8, 0.1_6_3_2], [-0.1_5_8_7, -0.1_6_6_7, -0.0_4_0_0], [-0.1_5_5_7, -0.1_6_7_1, -0.0_5_0_5]]			).to(_UpperCamelCase			)

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








import argparse
import copy



def _a				(	lowerCamelCase:   List[Any] )	->						List[str]:







      '''simple docstring'''






      __A          =				{}

      with open(lowerCamelCase ) as f:
            for line in f:
                  if line.split()[0] not in dict_of_neighbours:
                        __A          =				[]
                        _list.append([line.split()[1], line.split()[2]] )
                        __A          =				_list
                  else:
                        dict_of_neighbours[line.split()[0]].append(
                            [line.split()[1], line.split()[2]] )
                  if line.split()[1] not in dict_of_neighbours:
                        __A          =				[]
                        _list.append([line.split()[0], line.split()[2]] )
                        __A          =				_list
                  else:
                        dict_of_neighbours[line.split()[1]].append(
                            [line.split()[0], line.split()[2]] )

      return dict_of_neighbours



def _a				(	lowerCamelCase:   Any					,				lowerCamelCase:   Optional[Any] )	->						Dict:







      '''simple docstring'''






      with open(lowerCamelCase ) as f:
            __A          =				f.read(1 )
      __A          =				start_node

      __A          =				[]

      __A          =				start_node

      __A          =				0
      while visiting not in first_solution:
            __A          =				1_00_00
            for k in dict_of_neighbours[visiting]:
                  if int(k[1] ) < int(lowerCamelCase ) and k[0] not in first_solution:
                        __A          =				k[1]
                        __A          =				k[0]

            first_solution.append(lowerCamelCase )
            __A          =				distance_of_first_solution + int(lowerCamelCase )
            __A          =				best_node

      first_solution.append(lowerCamelCase )

      __A          =				0
      for k in dict_of_neighbours[first_solution[-2]]:
            if k[0] == start_node:
                  break
            position += 1

      __A          =				(
          distance_of_first_solution
          + int(dict_of_neighbours[first_solution[-2]][position][1] )
          - 1_00_00
      )
      return first_solution, distance_of_first_solution



def _a				(	lowerCamelCase:   List[str]					,				lowerCamelCase:   Any )	->						Any:







      '''simple docstring'''






      __A          =				[]

      for n in solution[1:-1]:
            __A          =				solution.index(lowerCamelCase )
            for kn in solution[1:-1]:
                  __A          =				solution.index(lowerCamelCase )
                  if n == kn:
                        continue

                  __A          =				copy.deepcopy(lowerCamelCase )
                  __A          =				kn
                  __A          =				n

                  __A          =				0

                  for k in _tmp[:-1]:
                        __A          =				_tmp[_tmp.index(lowerCamelCase ) + 1]
                        for i in dict_of_neighbours[k]:
                              if i[0] == next_node:
                                    __A          =				distance + int(i[1] )
                  _tmp.append(lowerCamelCase )

                  if _tmp not in neighborhood_of_solution:
                        neighborhood_of_solution.append(_tmp )

      __A          =				len(neighborhood_of_solution[0] ) - 1

      neighborhood_of_solution.sort(key=lambda lowerCamelCase : x[index_of_last_item_in_the_list] )
      return neighborhood_of_solution



def _a				(	lowerCamelCase:   Optional[int]					,				lowerCamelCase:   Dict					,				lowerCamelCase:   Any					,				lowerCamelCase:   Optional[int]					,				lowerCamelCase:   Union[str, Any] )	->						Any:







      '''simple docstring'''






      __A          =				1
      __A          =				first_solution
      __A          =				[]
      __A          =				distance_of_first_solution
      __A          =				solution

      while count <= iters:
            __A          =				find_neighborhood(lowerCamelCase					,				lowerCamelCase )
            __A          =				0
            __A          =				neighborhood[index_of_best_solution]
            __A          =				len(lowerCamelCase ) - 1

            __A          =				False
            while not found:
                  __A          =				0
                  while i < len(lowerCamelCase ):
                        if best_solution[i] != solution[i]:
                              __A          =				best_solution[i]
                              __A          =				solution[i]
                              break
                        __A          =				i + 1

                  if [first_exchange_node, second_exchange_node] not in tabu_list and [
                      second_exchange_node,
                      first_exchange_node,
                  ] not in tabu_list:
                        tabu_list.append([first_exchange_node, second_exchange_node] )
                        __A          =				True
                        __A          =				best_solution[:-1]
                        __A          =				neighborhood[index_of_best_solution][best_cost_index]
                        if cost < best_cost:
                              __A          =				cost
                              __A          =				solution
                  else:
                        __A          =				index_of_best_solution + 1
                        __A          =				neighborhood[index_of_best_solution]

            if len(lowerCamelCase ) >= size:
                  tabu_list.pop(0 )

            __A          =				count + 1

      return best_solution_ever, best_cost



def _a				(	lowerCamelCase:   List[str]=None )	->						str:







      '''simple docstring'''






      __A          =				generate_neighbours(args.File )

      __A   ,						__A          =				generate_first_solution(
          args.File					,				lowerCamelCase )

      __A   ,						__A          =				tabu_search(
          lowerCamelCase					,				lowerCamelCase					,				lowerCamelCase					,				args.Iterations					,				args.Size					,				)

      print(F"""Best solution: {best_sol}, with total distance: {best_cost}.""" )


if __name__ == "__main__":
       snake_case__					:							Tuple													=     argparse.ArgumentParser(description='Tabu Search')
       parser.add_argument(
           '-f',
           '--File',
           type=str,
           help='Path to the file containing the data',
           required=True,
       )
       parser.add_argument(
           '-i',
           '--Iterations',
           type=int,
           help='How many iterations the algorithm should perform',
           required=True,
       )
       parser.add_argument(
           '-s', '--Size', type=int, help='Size of the tabu list', required=True
       )

       # Pass the arguments to main method
       main(parser.parse_args())





