import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available


if is_torch_available():
    import numpy as np
    import torch

if is_vision_available():
    from PIL import Image







def     A__	(       __A ,			__A=False ,			__A=False ,			__A=False						):







    '''simple docstring'''
    assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

    _lowerCamelCase  :		Dict			    =    []
    for i in range(image_processor_tester.batch_size						):
        if equal_resolution:
            _lowerCamelCase  :		Tuple			    =    image_processor_tester.max_resolution
        else:
            # To avoid getting image width/height 0
            _lowerCamelCase  :		Optional[Any]			    =    image_processor_tester.min_resolution
            if getattr(_snake_case ,			"""size_divisor""" ,			_snake_case						):
                # If `size_divisor` is defined, the image needs to have width/size >= `size_divisor`
                _lowerCamelCase  :		Any			    =    max(image_processor_tester.size_divisor ,			_snake_case						)
            _lowerCamelCase  :		str			    =    np.random.choice(np.arange(_snake_case ,			image_processor_tester.max_resolution						) ,			2						)
        image_inputs.append(
            np.random.randint(255 ,			size=(image_processor_tester.num_channels, width, height) ,			dtype=np.uinta						)						)

    if not numpify and not torchify:
        # PIL expects the channel dimension as last dimension
        _lowerCamelCase  :		List[Any]			    =    [Image.fromarray(np.moveaxis(_snake_case ,			0 ,			-1						)						) for image in image_inputs]

    if torchify:
        _lowerCamelCase  :		Optional[Any]			    =    [torch.from_numpy(_snake_case						) for image in image_inputs]

    return image_inputs







def     A__	(       __A ,			__A=10 ,			__A=10 ,			__A=False ,			__A=False						):







    '''simple docstring'''
    _lowerCamelCase  :		Optional[int]			    =    []
    for i in range(image_processor_tester.num_frames						):
        video.append(np.random.randint(255 ,			size=(image_processor_tester.num_channels, width, height) ,			dtype=np.uinta						)						)

    if not numpify and not torchify:
        # PIL expects the channel dimension as last dimension
        _lowerCamelCase  :		Tuple			    =    [Image.fromarray(np.moveaxis(_snake_case ,			0 ,			-1						)						) for frame in video]

    if torchify:
        _lowerCamelCase  :		Optional[Any]			    =    [torch.from_numpy(_snake_case						) for frame in video]

    return video







def     A__	(       __A ,			__A=False ,			__A=False ,			__A=False						):







    '''simple docstring'''
    assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

    _lowerCamelCase  :		int			    =    []
    for i in range(image_processor_tester.batch_size						):
        if equal_resolution:
            _lowerCamelCase  :		Tuple			    =    image_processor_tester.max_resolution
        else:
            _lowerCamelCase  :		List[Any]			    =    np.random.choice(
                np.arange(image_processor_tester.min_resolution ,			image_processor_tester.max_resolution						) ,			2						)
            _lowerCamelCase  :		Any			    =    prepare_video(
                image_processor_tester=_snake_case ,			width=_snake_case ,			height=_snake_case ,			numpify=_snake_case ,			torchify=_snake_case ,			)
        video_inputs.append(_snake_case						)

    return video_inputs




class 						__snake_case						:





      '''simple docstring'''






      _snake_case     		=							None



      def 						_SCREAMING_SNAKE_CASE     (       self  :					Any)					->int:


          """simple docstring"""


          _lowerCamelCase  :		Union[str, Any]			    =    self.image_processing_class(**self.image_processor_dict)
          _lowerCamelCase  :		List[Any]			    =    json.loads(image_processor.to_json_string())
          for key, value in self.image_processor_dict.items():
              self.assertEqual(obj[key]     ,	UpperCamelCase_)



      def 						_SCREAMING_SNAKE_CASE     (       self  :					str)					->Dict:


          """simple docstring"""


          _lowerCamelCase  :		int			    =    self.image_processing_class(**self.image_processor_dict)

          with tempfile.TemporaryDirectory() as tmpdirname:
              _lowerCamelCase  :		Optional[Any]			    =    os.path.join(UpperCamelCase_     ,	"""image_processor.json""")
              image_processor_first.to_json_file(UpperCamelCase_)
              _lowerCamelCase  :		Any			    =    self.image_processing_class.from_json_file(UpperCamelCase_)

          self.assertEqual(image_processor_second.to_dict()     ,	image_processor_first.to_dict())



      def 						_SCREAMING_SNAKE_CASE     (       self  :					Tuple)					->Tuple:


          """simple docstring"""


          _lowerCamelCase  :		Optional[int]			    =    self.image_processing_class(**self.image_processor_dict)

          with tempfile.TemporaryDirectory() as tmpdirname:
              _lowerCamelCase  :		List[str]			    =    image_processor_first.save_pretrained(UpperCamelCase_)[0]
              check_json_file_has_correct_format(UpperCamelCase_)
              _lowerCamelCase  :		Any			    =    self.image_processing_class.from_pretrained(UpperCamelCase_)

          self.assertEqual(image_processor_second.to_dict()     ,	image_processor_first.to_dict())



      def 						_SCREAMING_SNAKE_CASE     (       self  :					Optional[int])					->Dict:


          """simple docstring"""


          _lowerCamelCase  :		List[str]			    =    self.image_processing_class()
          self.assertIsNotNone(UpperCamelCase_)




      @require_torch
      @require_vision
      def 						_SCREAMING_SNAKE_CASE     (       self  :					Dict)					->Tuple:


          """simple docstring"""


          if self.test_cast_dtype is not None:
              # Initialize image_processor
              _lowerCamelCase  :		Any			    =    self.image_processing_class(**self.image_processor_dict)

              # create random PyTorch tensors
              _lowerCamelCase  :		List[Any]			    =    prepare_image_inputs(self.image_processor_tester     ,	equal_resolution=UpperCamelCase_     ,	torchify=UpperCamelCase_)

              _lowerCamelCase  :		str			    =    image_processor(UpperCamelCase_     ,	return_tensors="""pt""")
              # for layoutLM compatiblity
              self.assertEqual(encoding.pixel_values.device     ,	torch.device("""cpu"""))
              self.assertEqual(encoding.pixel_values.dtype     ,	torch.floataa)

              _lowerCamelCase  :		Optional[int]			    =    image_processor(UpperCamelCase_     ,	return_tensors="""pt""").to(torch.floataa)
              self.assertEqual(encoding.pixel_values.device     ,	torch.device("""cpu"""))
              self.assertEqual(encoding.pixel_values.dtype     ,	torch.floataa)

              _lowerCamelCase  :		List[Any]			    =    image_processor(UpperCamelCase_     ,	return_tensors="""pt""").to("""cpu"""     ,	torch.bfloataa)
              self.assertEqual(encoding.pixel_values.device     ,	torch.device("""cpu"""))
              self.assertEqual(encoding.pixel_values.dtype     ,	torch.bfloataa)

              with self.assertRaises(UpperCamelCase_):
                  _lowerCamelCase  :		Union[str, Any]			    =    image_processor(UpperCamelCase_     ,	return_tensors="""pt""").to(torch.bfloataa     ,	"""cpu""")

              # Try with text + image feature
              _lowerCamelCase  :		Union[str, Any]			    =    image_processor(UpperCamelCase_     ,	return_tensors="""pt""")
              encoding.update({"""input_ids""": torch.LongTensor([[1, 2, 3], [4, 5, 6]])})
              _lowerCamelCase  :		str			    =    encoding.to(torch.floataa)

              self.assertEqual(encoding.pixel_values.device     ,	torch.device("""cpu"""))
              self.assertEqual(encoding.pixel_values.dtype     ,	torch.floataa)
              self.assertEqual(encoding.input_ids.dtype     ,	torch.long)








"""simple docstring"""





import unittest

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

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


if is_torch_available():
 import torch

 from transformers import (
     ErnieMForInformationExtraction,
     ErnieMForMultipleChoice,
     ErnieMForQuestionAnswering,
     ErnieMForSequenceClassification,
     ErnieMForTokenClassification,
     ErnieMModel,
 )
 from transformers.models.ernie_m.modeling_ernie_m import ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST



class 		snake_case_:






     def __init__(						self	:       Optional[int]       ,					UpperCamelCase_	:       Dict       ,					UpperCamelCase_	:       Optional[int]=1_3       ,					UpperCamelCase_	:       Dict=7       ,					UpperCamelCase_	:       Dict=True       ,					UpperCamelCase_	:       str=True       ,					UpperCamelCase_	:       int=True       ,					UpperCamelCase_	:       Optional[Any]=9_9       ,					UpperCamelCase_	:       Optional[int]=3_2       ,					UpperCamelCase_	:       Any=5       ,					UpperCamelCase_	:       Any=4       ,					UpperCamelCase_	:       Tuple=3_7       ,					UpperCamelCase_	:       Tuple="gelu"       ,					UpperCamelCase_	:       Union[str, Any]=0.1       ,					UpperCamelCase_	:       List[Any]=0.1       ,					UpperCamelCase_	:       int=5_1_2       ,					UpperCamelCase_	:       int=1_6       ,					UpperCamelCase_	:       List[Any]=2       ,					UpperCamelCase_	:       str=0.02       ,					UpperCamelCase_	:       int=3       ,					UpperCamelCase_	:       str=4       ,					UpperCamelCase_	:       Union[str, Any]=None       ,					):
           lowerCAmelCase       :						List[str]							= parent
           lowerCAmelCase       :						str							= batch_size
           lowerCAmelCase       :						Dict							= seq_length
           lowerCAmelCase       :						Dict							= is_training
           lowerCAmelCase       :						Tuple							= use_input_mask
           lowerCAmelCase       :						str							= use_labels
           lowerCAmelCase       :						Optional[Any]							= vocab_size
           lowerCAmelCase       :						Optional[Any]							= hidden_size
           lowerCAmelCase       :						Optional[int]							= num_hidden_layers
           lowerCAmelCase       :						List[Any]							= num_attention_heads
           lowerCAmelCase       :						Tuple							= intermediate_size
           lowerCAmelCase       :						Tuple							= hidden_act
           lowerCAmelCase       :						Optional[int]							= hidden_dropout_prob
           lowerCAmelCase       :						str							= attention_probs_dropout_prob
           lowerCAmelCase       :						str							= max_position_embeddings
           lowerCAmelCase       :						List[str]							= type_vocab_size
           lowerCAmelCase       :						str							= type_sequence_label_size
           lowerCAmelCase       :						int							= initializer_range
           lowerCAmelCase       :						Optional[Any]							= num_labels
           lowerCAmelCase       :						Any							= num_choices
           lowerCAmelCase       :						str							= scope






     def   lowerCamelCase__  (						self	:       Dict					):
           lowerCAmelCase       :						str							= ids_tensor([self.batch_size, self.seq_length]       ,					self.vocab_size					)

           lowerCAmelCase       :						List[Any]							= None
           if self.use_input_mask:
                 lowerCAmelCase       :						str							= random_attention_mask([self.batch_size, self.seq_length]					)

           lowerCAmelCase       :						List[Any]							= None
           lowerCAmelCase       :						str							= None
           lowerCAmelCase       :						str							= None
           if self.use_labels:
                 lowerCAmelCase       :						Tuple							= ids_tensor([self.batch_size]       ,					self.type_sequence_label_size					)
                 lowerCAmelCase       :						Dict							= ids_tensor([self.batch_size, self.seq_length]       ,					self.num_labels					)
                 lowerCAmelCase       :						List[Any]							= ids_tensor([self.batch_size]       ,					self.num_choices					)

           lowerCAmelCase       :						Any							= self.get_config()

           return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels






     def   lowerCamelCase__  (						self	:       str					):
           lowerCAmelCase       :						Tuple							= ids_tensor([self.batch_size, self.seq_length]       ,					self.vocab_size					)

           lowerCAmelCase       :						Optional[Any]							= None
           if self.use_input_mask:
                 lowerCAmelCase       :						Union[str, Any]							= random_attention_mask([self.batch_size, self.seq_length]					)
           lowerCAmelCase       :						Dict							= self.get_config()

           return config, input_ids, input_mask






     def   lowerCamelCase__  (						self	:       Union[str, Any]					):
           return ErnieMConfig(
               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   lowerCamelCase__  (						self	:       Union[str, Any]       ,					UpperCamelCase_	:       Tuple       ,					UpperCamelCase_	:       Union[str, Any]       ,					UpperCamelCase_	:       Optional[Any]       ,					UpperCamelCase_	:       Dict       ,					UpperCamelCase_	:       Union[str, Any]       ,					UpperCamelCase_	:       Optional[Any]					):
           lowerCAmelCase       :						List[str]							= ErnieMModel(config=UpperCamelCase_					)
           model.to(UpperCamelCase_					)
           model.eval()
           lowerCAmelCase       :						List[Any]							= model(UpperCamelCase_       ,					return_dict=UpperCamelCase_					)
           self.parent.assertEqual(result.last_hidden_state.shape       ,					(self.batch_size, self.seq_length, self.hidden_size)					)






     def   lowerCamelCase__  (						self	:       Union[str, Any]       ,					UpperCamelCase_	:       Union[str, Any]       ,					UpperCamelCase_	:       Optional[Any]       ,					UpperCamelCase_	:       int       ,					UpperCamelCase_	:       List[Any]       ,					UpperCamelCase_	:       List[Any]       ,					UpperCamelCase_	:       Optional[Any]					):
           lowerCAmelCase       :						Optional[int]							= ErnieMForQuestionAnswering(config=UpperCamelCase_					)
           model.to(UpperCamelCase_					)
           model.eval()
           lowerCAmelCase       :						List[Any]							= model(
               UpperCamelCase_       ,					attention_mask=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   lowerCamelCase__  (						self	:       Dict       ,					UpperCamelCase_	:       Optional[int]       ,					UpperCamelCase_	:       Any       ,					UpperCamelCase_	:       List[str]       ,					UpperCamelCase_	:       Dict       ,					UpperCamelCase_	:       Optional[Any]       ,					UpperCamelCase_	:       Union[str, Any]					):
           lowerCAmelCase       :						Tuple							= ErnieMForInformationExtraction(config=UpperCamelCase_					)
           model.to(UpperCamelCase_					)
           model.eval()
           lowerCAmelCase       :						Tuple							= torch.ones_like(UpperCamelCase_       ,					dtype=torch.floataa					)
           lowerCAmelCase       :						str							= model(
               UpperCamelCase_       ,					attention_mask=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   lowerCamelCase__  (						self	:       Optional[int]       ,					UpperCamelCase_	:       Optional[int]       ,					UpperCamelCase_	:       Dict       ,					UpperCamelCase_	:       int       ,					UpperCamelCase_	:       int       ,					UpperCamelCase_	:       Union[str, Any]       ,					UpperCamelCase_	:       Any					):
           lowerCAmelCase       :						Union[str, Any]							= self.num_labels
           lowerCAmelCase       :						Tuple							= ErnieMForSequenceClassification(UpperCamelCase_					)
           model.to(UpperCamelCase_					)
           model.eval()
           lowerCAmelCase       :						Union[str, Any]							= model(UpperCamelCase_       ,					attention_mask=UpperCamelCase_       ,					labels=UpperCamelCase_					)
           self.parent.assertEqual(result.logits.shape       ,					(self.batch_size, self.num_labels)					)






     def   lowerCamelCase__  (						self	:       Optional[int]       ,					UpperCamelCase_	:       Any       ,					UpperCamelCase_	:       List[str]       ,					UpperCamelCase_	:       int       ,					UpperCamelCase_	:       Dict       ,					UpperCamelCase_	:       str       ,					UpperCamelCase_	:       List[str]					):
           lowerCAmelCase       :						Union[str, Any]							= self.num_labels
           lowerCAmelCase       :						List[Any]							= ErnieMForTokenClassification(config=UpperCamelCase_					)
           model.to(UpperCamelCase_					)
           model.eval()
           input_ids.to(UpperCamelCase_					)
           input_mask.to(UpperCamelCase_					)
           token_labels.to(UpperCamelCase_					)

           lowerCAmelCase       :						Optional[Any]							= model(UpperCamelCase_       ,					attention_mask=UpperCamelCase_       ,					labels=UpperCamelCase_					)

           self.parent.assertEqual(result.logits.shape       ,					(self.batch_size, self.seq_length, self.num_labels)					)






     def   lowerCamelCase__  (						self	:       Any       ,					UpperCamelCase_	:       str       ,					UpperCamelCase_	:       Optional[int]       ,					UpperCamelCase_	:       Tuple       ,					UpperCamelCase_	:       Dict       ,					UpperCamelCase_	:       Dict       ,					UpperCamelCase_	:       str					):
           lowerCAmelCase       :						Union[str, Any]							= self.num_choices
           lowerCAmelCase       :						Any							= ErnieMForMultipleChoice(config=UpperCamelCase_					)
           model.to(UpperCamelCase_					)
           model.eval()
           lowerCAmelCase       :						Any							= input_ids.unsqueeze(1					).expand(-1       ,					self.num_choices       ,					-1					).contiguous()
           lowerCAmelCase       :						int							= input_mask.unsqueeze(1					).expand(-1       ,					self.num_choices       ,					-1					).contiguous()
           lowerCAmelCase       :						Any							= model(
               UpperCamelCase_       ,					attention_mask=UpperCamelCase_       ,					labels=UpperCamelCase_       ,					)
           self.parent.assertEqual(result.logits.shape       ,					(self.batch_size, self.num_choices)					)






     def   lowerCamelCase__  (						self	:       Tuple					):
           lowerCAmelCase       :						List[Any]							= self.prepare_config_and_inputs()
           (
               (
               lowerCAmelCase
           ),   (
               lowerCAmelCase
           ),   (
               lowerCAmelCase
           ),   (
               lowerCAmelCase
           ),   (
               lowerCAmelCase
           ),   (
               lowerCAmelCase
           ),   
           )       :						str							= config_and_inputs
           lowerCAmelCase       :						Dict							= {'''input_ids''': input_ids, '''attention_mask''': input_mask}
           return config, inputs_dict



@require_torch
class 		snake_case_(							a__				,       a__				,       unittest.TestCase      ):
     __UpperCamelCase	=       (
         (
             ErnieMModel,
             ErnieMForMultipleChoice,
             ErnieMForQuestionAnswering,
             ErnieMForSequenceClassification,
             ErnieMForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     __UpperCamelCase	=       ()
     __UpperCamelCase	=       (
         {
             '''feature-extraction''': ErnieMModel,
             '''question-answering''': ErnieMForQuestionAnswering,
             '''text-classification''': ErnieMForSequenceClassification,
             '''token-classification''': ErnieMForTokenClassification,
             '''zero-shot''': ErnieMForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     __UpperCamelCase	=       False






     def   lowerCamelCase__  (						self	:       Optional[Any]       ,					UpperCamelCase_	:       str       ,					UpperCamelCase_	:       List[Any]       ,					UpperCamelCase_	:       Tuple       ,					UpperCamelCase_	:       int       ,					UpperCamelCase_	:       Any					):
           if pipeline_test_casse_name == "QAPipelineTests":
                 return True

           return False






     def   lowerCamelCase__  (						self	:       Dict					):
           lowerCAmelCase       :						str							= ErnieMModelTester(self					)
           lowerCAmelCase       :						Optional[Any]							= ConfigTester(self       ,					config_class=UpperCamelCase_       ,					hidden_size=3_7					)






     def   lowerCamelCase__  (						self	:       Tuple					):
           self.config_tester.run_common_tests()






     def   lowerCamelCase__  (						self	:       List[str]					):
           lowerCAmelCase       :						str							= self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCamelCase_					)






     def   lowerCamelCase__  (						self	:       Union[str, Any]					):
           lowerCAmelCase       :						Optional[Any]							= self.model_tester.prepare_config_and_inputs()
           for type in ["absolute", "relative_key", "relative_key_query"]:
                 lowerCAmelCase       :						Union[str, Any]							= type
                 self.model_tester.create_and_check_model(*UpperCamelCase_					)






     def   lowerCamelCase__  (						self	:       Tuple					):
           lowerCAmelCase       :						Dict							= self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase_					)






     def   lowerCamelCase__  (						self	:       Dict					):
           lowerCAmelCase       :						int							= self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_question_answering(*UpperCamelCase_					)






     def   lowerCamelCase__  (						self	:       Optional[int]					):
           lowerCAmelCase       :						Tuple							= self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase_					)






     def   lowerCamelCase__  (						self	:       Tuple					):
           lowerCAmelCase       :						List[str]							= self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_information_extraction(*UpperCamelCase_					)






     def   lowerCamelCase__  (						self	:       List[Any]					):
           lowerCAmelCase       :						str							= self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*UpperCamelCase_					)






     @slow
     def   lowerCamelCase__  (						self	:       List[str]					):
           for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 lowerCAmelCase       :						int							= ErnieMModel.from_pretrained(UpperCamelCase_					)
                 self.assertIsNotNone(UpperCamelCase_					)



@require_torch
class 		snake_case_(							unittest.TestCase      ):






     @slow
     def   lowerCamelCase__  (						self	:       Dict					):
           lowerCAmelCase       :						Optional[int]							= ErnieMModel.from_pretrained('''susnato/ernie-m-base_pytorch'''					)
           model.eval()
           lowerCAmelCase       :						Optional[int]							= torch.tensor([[0, 1, 2, 3, 4, 5]]					)
           lowerCAmelCase       :						str							= model(UpperCamelCase_					)[0]

           # TODO Replace vocab size
           lowerCAmelCase       :						Any							= 7_6_8

           lowerCAmelCase       :						int							= torch.Size((1, 6, hidden_size)					)
           self.assertEqual(output.shape       ,					UpperCamelCase_					)

           lowerCAmelCase       :						str							= torch.tensor(
               [[[-0.0_012, 0.1_245, -0.0_214], [-0.0_742, 0.0_244, -0.0_771], [-0.0_333, 0.1_164, -0.1_554]]]					)

           self.assertTrue(torch.allclose(output[:, :3, :3]       ,					UpperCamelCase_       ,					atol=1E-3					)					)


