






"""simple docstring"""


import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
       MODEL_MAPPING,
       EfficientFormerForImageClassification,
       EfficientFormerForImageClassificationWithTeacher,
       EfficientFormerModel,
   )
   from transformers.models.efficientformer.modeling_efficientformer import (
       EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
   )


if is_vision_available():
   from PIL import Image

   from transformers import EfficientFormerImageProcessor






class __a :



  def __init__(self	:		Union[str, Any]					,      lowercase_	:		Dict					,      lowercase_	:		int = 13					,      lowercase_	:		List[str] = 64					,      lowercase_	:		int = 2					,      lowercase_	:		Optional[Any] = 3					,      lowercase_	:		List[str] = 3					,      lowercase_	:		Optional[int] = True					,      lowercase_	:		Dict = True					,      lowercase_	:		str = 128					,      lowercase_	:		int=[16, 32, 64, 128]					,      lowercase_	:		Union[str, Any] = 7					,      lowercase_	:		List[Any] = 4					,      lowercase_	:		Optional[Any] = 37					,      lowercase_	:		str = "gelu"					,      lowercase_	:		List[Any] = 0.1					,      lowercase_	:		Optional[int] = 0.1					,      lowercase_	:		Optional[int] = 10					,      lowercase_	:		List[Any] = 0.02					,      lowercase_	:		Optional[Any] = 2					,      lowercase_	:		int = 1					,      lowercase_	:		Dict = 128					,      lowercase_	:		List[str] = [2, 2, 2, 2]					,      lowercase_	:		Union[str, Any] = 2					,      lowercase_	:		int = 2					,      )		->				Any:
   __A						:							Dict      =						parent
   __A						:							int      =						batch_size
   __A						:							List[Any]      =						image_size
   __A						:							int      =						patch_size
   __A						:							int      =						num_channels
   __A						:							List[str]      =						is_training
   __A						:							Union[str, Any]      =						use_labels
   __A						:							Tuple      =						hidden_size
   __A						:							int      =						num_hidden_layers
   __A						:							Optional[int]      =						num_attention_heads
   __A						:							List[str]      =						intermediate_size
   __A						:							Dict      =						hidden_act
   __A						:							Optional[int]      =						hidden_dropout_prob
   __A						:							int      =						attention_probs_dropout_prob
   __A						:							Dict      =						type_sequence_label_size
   __A						:							int      =						initializer_range
   __A						:							Optional[Any]      =						encoder_stride
   __A						:							str      =						num_attention_outputs
   __A						:							Any      =						embed_dim
   __A						:							str      =						embed_dim + 1
   __A						:							int      =						resolution
   __A						:							List[str]      =						depths
   __A						:							int      =						hidden_sizes
   __A						:							List[Any]      =						dim
   __A						:							Union[str, Any]      =						mlp_expansion_ratio



  def     A_					(self	:		Optional[int] )		->				str:
   __A						:							int      =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

   __A						:							Optional[int]      =						None
   if self.use_labels:
    __A						:							Tuple      =						ids_tensor([self.batch_size]					,      self.type_sequence_label_size )

   __A						:							List[str]      =						self.get_config()
   return config, pixel_values, labels



  def     A_					(self	:		List[Any] )		->				Dict:
   return EfficientFormerConfig(
       image_size=self.image_size					,      patch_size=self.patch_size					,      num_channels=self.num_channels					,      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					,      is_decoder=SCREAMING_SNAKE_CASE_					,      initializer_range=self.initializer_range					,      encoder_stride=self.encoder_stride					,      resolution=self.resolution					,      depths=self.depths					,      hidden_sizes=self.hidden_sizes					,      dim=self.dim					,      mlp_expansion_ratio=self.mlp_expansion_ratio					,      )



  def     A_					(self	:		str					,      lowercase_	:		Any					,      lowercase_	:		Optional[int]					,      lowercase_	:		Optional[int] )		->				Union[str, Any]:
   __A						:							Union[str, Any]      =						EfficientFormerModel(config=SCREAMING_SNAKE_CASE_ )
   model.to(SCREAMING_SNAKE_CASE_ )
   model.eval()
   __A						:							Any      =						model(SCREAMING_SNAKE_CASE_ )
   self.parent.assertEqual(result.last_hidden_state.shape					,      (self.batch_size, self.seq_length, self.hidden_size) )



  def     A_					(self	:		List[Any]					,      lowercase_	:		Optional[int]					,      lowercase_	:		List[Any]					,      lowercase_	:		Union[str, Any] )		->				List[Any]:
   __A						:							List[Any]      =						self.type_sequence_label_size
   __A						:							Tuple      =						EfficientFormerForImageClassification(SCREAMING_SNAKE_CASE_ )
   model.to(SCREAMING_SNAKE_CASE_ )
   model.eval()
   __A						:							List[Any]      =						model(SCREAMING_SNAKE_CASE_					,      labels=SCREAMING_SNAKE_CASE_ )
   self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.type_sequence_label_size) )

   # test greyscale images
   __A						:							List[Any]      =						1
   __A						:							Tuple      =						EfficientFormerForImageClassification(SCREAMING_SNAKE_CASE_ )
   model.to(SCREAMING_SNAKE_CASE_ )
   model.eval()

   __A						:							Union[str, Any]      =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
   __A						:							Optional[int]      =						model(SCREAMING_SNAKE_CASE_ )
   self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.type_sequence_label_size) )



  def     A_					(self	:		Tuple )		->				Tuple:
   __A						:							Optional[int]      =						self.prepare_config_and_inputs()
   (
       (
       __A				
   )     ,       (
       __A				
   )     ,       (
       __A				
   )     ,       				
   )						:							Optional[int]      =						config_and_inputs
   __A						:							Dict      =						{'pixel_values': pixel_values}
   return config, inputs_dict






@require_torch
class __a ( SCREAMING_SNAKE_CASE_			,SCREAMING_SNAKE_CASE_			,unittest.TestCase					):
  __lowercase     :     Optional[Any]       						=       (
      (
          EfficientFormerModel,
          EfficientFormerForImageClassificationWithTeacher,
          EfficientFormerForImageClassification,
      )
      if is_torch_available()
      else ()
  )
  __lowercase     :     Optional[int]       						=       (
      {
          'feature-extraction': EfficientFormerModel,
          'image-classification': (
              EfficientFormerForImageClassification,
              EfficientFormerForImageClassificationWithTeacher,
          ),
      }
      if is_torch_available()
      else {}
  )
  __lowercase     :     Optional[Any]       						=       False

  __lowercase     :     Dict       						=       False
  __lowercase     :     List[Any]       						=       False
  __lowercase     :     Dict       						=       False



  def     A_					(self	:		Optional[Any] )		->				Tuple:
   __A						:							Any      =						EfficientFormerModelTester(self )
   __A						:							List[Any]      =						ConfigTester(
       self					,      config_class=SCREAMING_SNAKE_CASE_					,      has_text_modality=SCREAMING_SNAKE_CASE_					,      hidden_size=37 )



  def     A_					(self	:		Union[str, Any] )		->				Dict:
   self.config_tester.run_common_tests()



  @unittest.skip(reason='EfficientFormer does not use inputs_embeds' )
  def     A_					(self	:		Optional[int] )		->				List[Any]:
   pass



  @unittest.skip(reason='EfficientFormer does not support input and output embeddings' )
  def     A_					(self	:		Dict )		->				int:
   pass



  def     A_					(self	:		int )		->				int:
   __A     ,       __A						:							Tuple      =						self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
    __A						:							int      =						model_class(SCREAMING_SNAKE_CASE_ )
    __A						:							int      =						inspect.signature(model.forward )
    # signature.parameters is an OrderedDict => so arg_names order is deterministic
    __A						:							str      =						[*signature.parameters.keys()]

    __A						:							List[Any]      =						['pixel_values']
    self.assertListEqual(arg_names[:1]					,      SCREAMING_SNAKE_CASE_ )



  def     A_					(self	:		str )		->				Optional[Any]:






   def check_hidden_states_output(lowercase_	:		List[str]					,      lowercase_	:		int					,      lowercase_	:		Optional[int] ):
    __A						:							int      =						model_class(SCREAMING_SNAKE_CASE_ )
    model.to(SCREAMING_SNAKE_CASE_ )
    model.eval()

    with torch.no_grad():
     __A						:							Any      =						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_ ) )

    __A						:							Optional[int]      =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

    __A						:							Dict      =						getattr(
        self.model_tester					,      'expected_num_hidden_layers'					,      self.model_tester.num_hidden_layers + 1 )
    self.assertEqual(len(SCREAMING_SNAKE_CASE_ )					,      SCREAMING_SNAKE_CASE_ )

    if hasattr(self.model_tester					,      'encoder_seq_length' ):
     __A						:							Optional[Any]      =						self.model_tester.encoder_seq_length
     if hasattr(self.model_tester					,      'chunk_length' ) and self.model_tester.chunk_length > 1:
      __A						:							Any      =						seq_length * self.model_tester.chunk_length
    else:
     __A						:							Union[str, Any]      =						self.model_tester.seq_length

    self.assertListEqual(
        list(hidden_states[-1].shape[-2:] )					,      [seq_length, self.model_tester.hidden_size]					,      )

    if config.is_encoder_decoder:
     __A						:							List[str]      =						outputs.decoder_hidden_states

     self.assertIsInstance(SCREAMING_SNAKE_CASE_					,      (list, tuple) )
     self.assertEqual(len(SCREAMING_SNAKE_CASE_ )					,      SCREAMING_SNAKE_CASE_ )
     __A						:							Optional[Any]      =						getattr(self.model_tester					,      'seq_length'					,      SCREAMING_SNAKE_CASE_ )
     __A						:							Optional[Any]      =						getattr(self.model_tester					,      'decoder_seq_length'					,      SCREAMING_SNAKE_CASE_ )

     self.assertListEqual(
         list(hidden_states[-1].shape[-2:] )					,      [decoder_seq_length, self.model_tester.hidden_size]					,      )

   __A     ,       __A						:							Tuple      =						self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
    __A						:							Dict      =						True
    check_hidden_states_output(SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_ )

    # check that output_hidden_states also work using config
    del inputs_dict["output_hidden_states"]
    __A						:							Dict      =						True

    check_hidden_states_output(SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_ )



  def     A_					(self	:		Tuple					,      lowercase_	:		Tuple					,      lowercase_	:		int					,      lowercase_	:		int=False )		->				str:
   __A						:							Tuple      =						super()._prepare_for_class(SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_					,      return_labels=SCREAMING_SNAKE_CASE_ )

   if return_labels:
    if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
     del inputs_dict["labels"]

   return inputs_dict



  def     A_					(self	:		Tuple )		->				Optional[Any]:
   __A						:							Optional[Any]      =						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_ )



  @unittest.skip(reason='EfficientFormer does not implement masked image modeling yet' )
  def     A_					(self	:		Tuple )		->				Dict:
   __A						:							Optional[int]      =						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE_ )



  def     A_					(self	:		Optional[int] )		->				Optional[int]:
   __A						:							Dict      =						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_ )



  def     A_					(self	:		int )		->				int:






   if not self.model_tester.is_training:
    return

   __A     ,       __A						:							str      =						self.model_tester.prepare_config_and_inputs_for_common()
   __A						:							Dict      =						True

   for model_class in self.all_model_classes:
    # EfficientFormerForImageClassificationWithTeacher supports inference-only
    if (
        model_class in get_values(SCREAMING_SNAKE_CASE_ )
        or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
    ):
     continue
    __A						:							Optional[int]      =						model_class(SCREAMING_SNAKE_CASE_ )
    model.to(SCREAMING_SNAKE_CASE_ )
    model.train()
    __A						:							Dict      =						self._prepare_for_class(SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_					,      return_labels=SCREAMING_SNAKE_CASE_ )
    __A						:							Tuple      =						model(**SCREAMING_SNAKE_CASE_ ).loss
    loss.backward()



  def     A_					(self	:		Optional[int] )		->				str:
   __A     ,       __A						:							List[Any]      =						self.model_tester.prepare_config_and_inputs_for_common()

   __A						:							Optional[Any]      =						[
       {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
       {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
       {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
   ]

   for model_class in self.all_model_classes:
    if (
        model_class
        not in [
            *get_values(SCREAMING_SNAKE_CASE_ ),
        ]
        or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
    ):
     continue

    for problem_type in problem_types:
     with self.subTest(msg=f"Testing {model_class} with {problem_type['title']}" ):
      __A						:							List[str]      =						problem_type['title']
      __A						:							List[str]      =						problem_type['num_labels']

      __A						:							List[Any]      =						model_class(SCREAMING_SNAKE_CASE_ )
      model.to(SCREAMING_SNAKE_CASE_ )
      model.train()

      __A						:							Tuple      =						self._prepare_for_class(SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_					,      return_labels=SCREAMING_SNAKE_CASE_ )

      if problem_type["num_labels"] > 1:
       __A						:							List[Any]      =						inputs['labels'].unsqueeze(1 ).repeat(1					,      problem_type['num_labels'] )

      __A						:							List[Any]      =						inputs['labels'].to(problem_type['dtype'] )

      # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
      # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
      # they have the same size." which is a symptom something in wrong for the regression problem.
      # See https://github.com/huggingface/transformers/issues/11780
      with warnings.catch_warnings(record=SCREAMING_SNAKE_CASE_ ) as warning_list:
       __A						:							Any      =						model(**SCREAMING_SNAKE_CASE_ ).loss
      for w in warning_list:
       if "Using a target size that is different to the input size" in str(w.message ):
        raise ValueError(
            f"Something is going wrong in the regression problem: intercepted {w.message}" )

      loss.backward()



  @slow
  def     A_					(self	:		List[Any] )		->				Any:






   for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    __A						:							Tuple      =						EfficientFormerModel.from_pretrained(SCREAMING_SNAKE_CASE_ )
    self.assertIsNotNone(SCREAMING_SNAKE_CASE_ )



  def     A_					(self	:		Dict )		->				Union[str, Any]:
   __A     ,       __A						:							Union[str, Any]      =						self.model_tester.prepare_config_and_inputs_for_common()
   __A						:							int      =						True

   __A						:							Tuple      =						getattr(self.model_tester					,      'seq_length'					,      SCREAMING_SNAKE_CASE_ )
   __A						:							List[Any]      =						getattr(self.model_tester					,      'encoder_seq_length'					,      SCREAMING_SNAKE_CASE_ )
   __A						:							Optional[int]      =						getattr(self.model_tester					,      'key_length'					,      SCREAMING_SNAKE_CASE_ )
   __A						:							Any      =						getattr(self.model_tester					,      'chunk_length'					,      SCREAMING_SNAKE_CASE_ )

   if chunk_length is not None and hasattr(self.model_tester					,      'num_hashes' ):
    __A						:							Any      =						encoder_seq_length * self.model_tester.num_hashes

   for model_class in self.all_model_classes:
    __A						:							Any      =						True
    __A						:							str      =						False
    __A						:							Optional[Any]      =						True
    __A						:							Any      =						model_class(SCREAMING_SNAKE_CASE_ )
    model.to(SCREAMING_SNAKE_CASE_ )
    model.eval()
    with torch.no_grad():
     __A						:							Optional[int]      =						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_ ) )
    __A						:							Optional[Any]      =						outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
    self.assertEqual(len(SCREAMING_SNAKE_CASE_ )					,      self.model_tester.num_attention_outputs )

    # check that output_attentions also work using config
    del inputs_dict["output_attentions"]
    __A						:							str      =						True
    __A						:							Optional[int]      =						model_class(SCREAMING_SNAKE_CASE_ )
    model.to(SCREAMING_SNAKE_CASE_ )
    model.eval()
    with torch.no_grad():
     __A						:							List[Any]      =						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_ ) )
    __A						:							str      =						outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
    self.assertEqual(len(SCREAMING_SNAKE_CASE_ )					,      self.model_tester.num_attention_outputs )

    if chunk_length is not None:
     self.assertListEqual(
         list(attentions[0].shape[-4:] )					,      [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]					,      )
    else:
     self.assertListEqual(
         list(attentions[0].shape[-3:] )					,      [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]					,      )






def 					a			(  )	->		Any:
 __A						:							Tuple      =						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'		)
 return image






@require_torch
@require_vision
class __a ( unittest.TestCase					):



  @cached_property
  def     A_					(self	:		List[Any] )		->				int:
   return (
       EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300' )
       if is_vision_available()
       else None
   )



  @slow
  def     A_					(self	:		Optional[Any] )		->				str:
   __A						:							Optional[Any]      =						EfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300' ).to(
       SCREAMING_SNAKE_CASE_ )

   __A						:							int      =						self.default_image_processor
   __A						:							Optional[int]      =						prepare_img()
   __A						:							Dict      =						image_processor(images=SCREAMING_SNAKE_CASE_					,      return_tensors='pt' ).to(SCREAMING_SNAKE_CASE_ )

   # forward pass
   with torch.no_grad():
    __A						:							int      =						model(**SCREAMING_SNAKE_CASE_ )

   # verify the logits
   __A						:							List[Any]      =						(1, 1_000)
   self.assertEqual(outputs.logits.shape					,      SCREAMING_SNAKE_CASE_ )

   __A						:							Union[str, Any]      =						torch.tensor([-0.0555, 0.4825, -0.0852] ).to(SCREAMING_SNAKE_CASE_ )
   self.assertTrue(torch.allclose(outputs.logits[0][:3]					,      SCREAMING_SNAKE_CASE_					,      atol=1E-4 ) )



  @slow
  def     A_					(self	:		List[Any] )		->				List[Any]:
   __A						:							List[Any]      =						EfficientFormerForImageClassificationWithTeacher.from_pretrained(
       'snap-research/efficientformer-l1-300' ).to(SCREAMING_SNAKE_CASE_ )

   __A						:							str      =						self.default_image_processor
   __A						:							Optional[int]      =						prepare_img()
   __A						:							Union[str, Any]      =						image_processor(images=SCREAMING_SNAKE_CASE_					,      return_tensors='pt' ).to(SCREAMING_SNAKE_CASE_ )

   # forward pass
   with torch.no_grad():
    __A						:							Union[str, Any]      =						model(**SCREAMING_SNAKE_CASE_ )

   # verify the logits
   __A						:							Any      =						(1, 1_000)
   self.assertEqual(outputs.logits.shape					,      SCREAMING_SNAKE_CASE_ )

   __A						:							Optional[int]      =						torch.tensor([-0.1312, 0.4353, -1.0499] ).to(SCREAMING_SNAKE_CASE_ )
   self.assertTrue(torch.allclose(outputs.logits[0][:3]					,      SCREAMING_SNAKE_CASE_					,      atol=1E-4 ) )







import inspect
import unittest

import requests

from transformers import MgpstrConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch
				from torch import nn

				from transformers import MgpstrForSceneTextRecognition


if is_vision_available():
				from PIL import Image

				from transformers import MgpstrProcessor






class 							SCREAMING_SNAKE_CASE__     :

							"""simple docstring"""






							def __init__(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_=False  ,						SCREAMING_SNAKE_CASE_=13  ,						SCREAMING_SNAKE_CASE_=(32, 128)  ,						SCREAMING_SNAKE_CASE_=4  ,						SCREAMING_SNAKE_CASE_=3  ,						SCREAMING_SNAKE_CASE_=27  ,						SCREAMING_SNAKE_CASE_=38  ,						SCREAMING_SNAKE_CASE_=99  ,						SCREAMING_SNAKE_CASE_=99  ,						SCREAMING_SNAKE_CASE_=32  ,						SCREAMING_SNAKE_CASE_=5  ,						SCREAMING_SNAKE_CASE_=4  ,						SCREAMING_SNAKE_CASE_=4.0  ,						SCREAMING_SNAKE_CASE_=257  ,						SCREAMING_SNAKE_CASE_=None  ,						)-> str:





													'''simple docstring'''






													__UpperCamelCase  	=      parent
													__UpperCamelCase  	=      is_training
													__UpperCamelCase  	=      batch_size
													__UpperCamelCase  	=      image_size
													__UpperCamelCase  	=      patch_size
													__UpperCamelCase  	=      num_channels
													__UpperCamelCase  	=      max_token_length
													__UpperCamelCase  	=      num_character_labels
													__UpperCamelCase  	=      num_bpe_labels
													__UpperCamelCase  	=      num_wordpiece_labels
													__UpperCamelCase  	=      hidden_size
													__UpperCamelCase  	=      num_hidden_layers
													__UpperCamelCase  	=      num_attention_heads
													__UpperCamelCase  	=      mlp_ratio
													__UpperCamelCase  	=      patch_embeds_hidden_size
													__UpperCamelCase  	=      output_hidden_states



							def      A__		(	self      )-> str:





													'''simple docstring'''






													__UpperCamelCase  	=      floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]      )
													__UpperCamelCase  	=      self.get_config()
													return config, pixel_values



							def      A__		(	self      )-> Tuple:





													'''simple docstring'''






													return MgpstrConfig(
													    image_size=self.image_size  ,						patch_size=self.patch_size  ,						num_channels=self.num_channels  ,						max_token_length=self.max_token_length  ,						num_character_labels=self.num_character_labels  ,						num_bpe_labels=self.num_bpe_labels  ,						num_wordpiece_labels=self.num_wordpiece_labels  ,						hidden_size=self.hidden_size  ,						num_hidden_layers=self.num_hidden_layers  ,						num_attention_heads=self.num_attention_heads  ,						mlp_ratio=self.mlp_ratio  ,						output_hidden_states=self.output_hidden_states  ,						)



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> Dict:





													'''simple docstring'''






													__UpperCamelCase  	=      MgpstrForSceneTextRecognition(SCREAMING_SNAKE_CASE_      )
													model.to(SCREAMING_SNAKE_CASE_      )
													model.eval()
													with torch.no_grad():
																			__UpperCamelCase  	=      model(SCREAMING_SNAKE_CASE_      )
													self.parent.assertEqual(
													    generated_ids[0][0].shape  ,						(self.batch_size, self.max_token_length, self.num_character_labels)      )



							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase  	=      self.prepare_config_and_inputs()
													__UpperCamelCase	,				__UpperCamelCase  	=      config_and_inputs
													__UpperCamelCase  	=      {'''pixel_values''': pixel_values}
													return config, inputs_dict






@require_torch
class 							SCREAMING_SNAKE_CASE__     (				SCREAMING_SNAKE_CASE_ ,		SCREAMING_SNAKE_CASE_ ,		unittest.TestCase     ):

							"""simple docstring"""






							_snake_case  		=	(MgpstrForSceneTextRecognition,) if is_torch_available() else ()
							_snake_case  		=	{'feature-extraction': MgpstrForSceneTextRecognition} if is_torch_available() else {}
							_snake_case  		=	False

							_snake_case  		=	False
							_snake_case  		=	False
							_snake_case  		=	False
							_snake_case  		=	False



							def      A__		(	self      )-> Tuple:





													'''simple docstring'''






													__UpperCamelCase  	=      MgpstrModelTester(self      )
													__UpperCamelCase  	=      ConfigTester(self  ,						config_class=SCREAMING_SNAKE_CASE_  ,						has_text_modality=SCREAMING_SNAKE_CASE_      )



							def      A__		(	self      )-> Any:





													'''simple docstring'''






													self.config_tester.run_common_tests()



							def      A__		(	self      )-> List[Any]:





													'''simple docstring'''






													__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_      )



							@unittest.skip(reason='''MgpstrModel does not use inputs_embeds'''      )
							def      A__		(	self      )-> List[str]:





													'''simple docstring'''






													pass



							def      A__		(	self      )-> str:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			self.assertIsInstance(model.get_input_embeddings()  ,						(nn.Module)      )
																			__UpperCamelCase  	=      model.get_output_embeddings()
																			self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE_  ,						nn.Linear      )      )



							def      A__		(	self      )-> List[Any]:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			__UpperCamelCase  	=      inspect.signature(model.forward      )
																			# signature.parameters is an OrderedDict => so arg_names order is deterministic
																			__UpperCamelCase  	=      [*signature.parameters.keys()]

																			__UpperCamelCase  	=      ['''pixel_values''']
																			self.assertListEqual(arg_names[:1]  ,						SCREAMING_SNAKE_CASE_      )



							@unittest.skip(reason='''MgpstrModel does not support feedforward chunking'''      )
							def      A__		(	self      )-> Optional[Any]:





													'''simple docstring'''






													pass



							def      A__		(	self      )-> int:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			if not model_class.supports_gradient_checkpointing:
																									continue

																			__UpperCamelCase  	=      True
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			self.assertTrue(model.is_gradient_checkpointing      )



							def      A__		(	self      )-> str:





													'''simple docstring'''






													def check_hidden_states_output(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      ):
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			model.to(SCREAMING_SNAKE_CASE_      )
																			model.eval()

																			with torch.no_grad():
																									__UpperCamelCase  	=      model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )      )

																			__UpperCamelCase  	=      outputs.hidden_states

																			__UpperCamelCase  	=      getattr(
																			    self.model_tester  ,						'''expected_num_hidden_layers'''  ,						self.model_tester.num_hidden_layers + 1      )
																			self.assertEqual(len(SCREAMING_SNAKE_CASE_      )  ,						SCREAMING_SNAKE_CASE_      )

																			self.assertListEqual(
																			    list(hidden_states[0].shape[-2:]      )  ,						[self.model_tester.patch_embeds_hidden_size, self.model_tester.hidden_size]  ,						)

													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      True
																			check_hidden_states_output(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )

																			# check that output_hidden_states also work using config
																			del inputs_dict["output_hidden_states"]
																			__UpperCamelCase  	=      True

																			check_hidden_states_output(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )



							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													__UpperCamelCase  	=      _config_zero_init(SCREAMING_SNAKE_CASE_      )
													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      model_class(config=SCREAMING_SNAKE_CASE_      )
																			for name, param in model.named_parameters():
																									if isinstance(SCREAMING_SNAKE_CASE_  ,						(nn.Linear, nn.Convad, nn.LayerNorm)      ):
																															if param.requires_grad:
																																					self.assertIn(
																																					    ((param.data.mean() * 1E9).round() / 1E9).item()  ,						[0.0, 1.0]  ,						msg=F"Parameter {name} of model {model_class} seems not properly initialized"  ,						)



							@unittest.skip(reason='''Retain_grad is tested in individual model tests'''      )
							def      A__		(	self      )-> List[Any]:





													'''simple docstring'''






													pass





def 						A_			(				)   ->     Dict:



						'''simple docstring'''

						__UpperCamelCase  	=      '''https://i.postimg.cc/ZKwLg2Gw/367-14.png'''
						__UpperCamelCase  	=      Image.open(requests.get(snake_case			,   stream=snake_case			).raw			).convert('''RGB'''			)
						return im






@require_vision
@require_torch
class 							SCREAMING_SNAKE_CASE__     (				unittest.TestCase     ):

							"""simple docstring"""






							@slow
							def      A__		(	self      )-> Optional[Any]:





													'''simple docstring'''






													__UpperCamelCase  	=      '''alibaba-damo/mgp-str-base'''
													__UpperCamelCase  	=      MgpstrForSceneTextRecognition.from_pretrained(SCREAMING_SNAKE_CASE_      ).to(SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      MgpstrProcessor.from_pretrained(SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      prepare_img()
													__UpperCamelCase  	=      processor(images=SCREAMING_SNAKE_CASE_  ,						return_tensors='''pt'''      ).pixel_values.to(SCREAMING_SNAKE_CASE_      )

													# forward pass
													with torch.no_grad():
																			__UpperCamelCase  	=      model(SCREAMING_SNAKE_CASE_      )

													# verify the logits
													self.assertEqual(outputs.logits[0].shape  ,						torch.Size((1, 27, 38)      )      )

													__UpperCamelCase  	=      processor.batch_decode(outputs.logits      )
													__UpperCamelCase  	=      '''ticket'''

													self.assertEqual(out_strs['''generated_text'''][0]  ,						SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      torch.tensor(
													    [[[-3_9.5_3_9_7, -4_4.4_0_2_4, -3_6.1_8_4_4], [-6_1.4_7_0_9, -6_3.8_6_3_9, -5_8.3_4_5_4], [-7_4.0_2_2_5, -6_8.5_4_9_4, -7_1.2_1_6_4]]]  ,						device=SCREAMING_SNAKE_CASE_  ,						)

													self.assertTrue(torch.allclose(outputs.logits[0][:, 1:4, 1:4]  ,						SCREAMING_SNAKE_CASE_  ,						atol=1E-4      )      )




