

'''simple docstring'''
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...file_utils import TensorType, is_torch_available
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


_snake_case     						=						logging.get_logger(__name__)

_snake_case     						=						{
    'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/config.json',
    # See all Blenderbot models at https://huggingface.co/models?filter=blenderbot
}


class      a__						(							lowerCamelCase_						):
   _SCREAMING_SNAKE_CASE					:  Union[str, Any]			 =							'blenderbot'
   _SCREAMING_SNAKE_CASE					:  List[Any]			 =							['past_key_values']
   _SCREAMING_SNAKE_CASE					:  Optional[Any]			 =							{'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}


   def __init__(				self    ,       _UpperCamelCase=8008    ,       _UpperCamelCase=128    ,       _UpperCamelCase=2    ,       _UpperCamelCase=10240    ,       _UpperCamelCase=32    ,       _UpperCamelCase=24    ,       _UpperCamelCase=10240    ,       _UpperCamelCase=32    ,       _UpperCamelCase=0.0    ,       _UpperCamelCase=0.0    ,       _UpperCamelCase=True    ,       _UpperCamelCase=True    ,       _UpperCamelCase="gelu"    ,       _UpperCamelCase=2560    ,       _UpperCamelCase=0.1    ,       _UpperCamelCase=0.0    ,       _UpperCamelCase=0.0    ,       _UpperCamelCase=0.0_2    ,       _UpperCamelCase=1    ,       _UpperCamelCase=False    ,       _UpperCamelCase=0    ,       _UpperCamelCase=1    ,       _UpperCamelCase=2    ,       _UpperCamelCase=3    ,       _UpperCamelCase=2    ,       **_UpperCamelCase    ,       )     ->   int:





      """simple docstring"""





      _lowercase    :   List[Any]      =     vocab_size
      _lowercase    :   Optional[Any]      =     max_position_embeddings
      _lowercase    :   Union[str, Any]      =     d_model
      _lowercase    :   Tuple      =     encoder_ffn_dim
      _lowercase    :   Dict      =     encoder_layers
      _lowercase    :   Union[str, Any]      =     encoder_attention_heads
      _lowercase    :   List[Any]      =     decoder_ffn_dim
      _lowercase    :   List[str]      =     decoder_layers
      _lowercase    :   List[Any]      =     decoder_attention_heads
      _lowercase    :   Any      =     dropout
      _lowercase    :   Any      =     attention_dropout
      _lowercase    :   List[Any]      =     activation_dropout
      _lowercase    :   Any      =     activation_function
      _lowercase    :   str      =     init_std
      _lowercase    :   Dict      =     encoder_layerdrop
      _lowercase    :   Optional[Any]      =     decoder_layerdrop
      _lowercase    :   Any      =     use_cache
      _lowercase    :   Tuple      =     encoder_layers
      _lowercase    :   str      =     scale_embedding  # scale factor will be sqrt(d_model) if True

      super().__init__(
          pad_token_id=_UpperCamelCase    ,       bos_token_id=_UpperCamelCase    ,       eos_token_id=_UpperCamelCase    ,       is_encoder_decoder=_UpperCamelCase    ,       decoder_start_token_id=_UpperCamelCase    ,       encoder_no_repeat_ngram_size=_UpperCamelCase    ,       forced_eos_token_id=_UpperCamelCase    ,       **_UpperCamelCase    ,       )




class      a__						(							lowerCamelCase_						):


   @property
   def 		_lowerCamelCase     (				self						)     ->   Union[str, Any]:





      """simple docstring"""





      if self.task in ["default", "seq2seq-lm"]:
         _lowercase    :   Any      =     OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
             ]						)
         if self.use_past:
            _lowercase    :   int      =     {0: "batch"}
            _lowercase    :   Union[str, Any]      =     {0: "batch", 1: "past_decoder_sequence + sequence"}
         else:
            _lowercase    :   Optional[Any]      =     {0: "batch", 1: "decoder_sequence"}
            _lowercase    :   str      =     {0: "batch", 1: "decoder_sequence"}
         if self.use_past:
            self.fill_with_past_key_values_(_UpperCamelCase    ,       direction="inputs"						)
      elif self.task == "causal-lm":
         _lowercase    :   Tuple      =     OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
             ]						)
         if self.use_past:
            _lowercase    :   Tuple      =     self.num_layers
            for i in range(_UpperCamelCase						):
               _lowercase    :   Union[str, Any]      =     {0: "batch", 2: "past_sequence + sequence"}
               _lowercase    :   Optional[int]      =     {0: "batch", 2: "past_sequence + sequence"}
      else:
         _lowercase    :   str      =     OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                 ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
                 ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
             ]						)

      return common_inputs


   @property
   # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
   def 		_lowerCamelCase     (				self						)     ->   Union[str, Any]:





      """simple docstring"""





      if self.task in ["default", "seq2seq-lm"]:
         _lowercase    :   Any      =     super().outputs
      else:
         _lowercase    :   Any      =     super(_UpperCamelCase    ,       self						).outputs
         if self.use_past:
            _lowercase    :   str      =     self.num_layers
            for i in range(_UpperCamelCase						):
               _lowercase    :   Dict      =     {0: "batch", 2: "past_sequence + sequence"}
               _lowercase    :   str      =     {0: "batch", 2: "past_sequence + sequence"}
      return common_outputs


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase = -1    ,       _UpperCamelCase = -1    ,       _UpperCamelCase = False    ,       _UpperCamelCase = None    ,       )     ->   Optional[Any]:





      """simple docstring"""





      _lowercase    :   Dict      =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
          _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)
      # Generate decoder inputs
      _lowercase    :   str      =     seq_length if not self.use_past else 1
      _lowercase    :   Tuple      =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
          _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)
      _lowercase    :   int      =     {f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
      _lowercase    :   Optional[int]      =     dict(**_UpperCamelCase    ,       **_UpperCamelCase						)

      if self.use_past:
         if not is_torch_available():
            raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."						)
         else:
            import torch
         _lowercase    :   Union[str, Any]      =     common_inputs["input_ids"].shape
         _lowercase    :   Optional[int]      =     common_inputs["decoder_input_ids"].shape[1]
         _lowercase    :   Any      =     self.num_attention_heads
         _lowercase    :   Any      =     (
             batch,
             num_encoder_attention_heads,
             encoder_seq_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )
         _lowercase    :   Tuple      =     decoder_seq_length
         _lowercase    :   Optional[int]      =     (
             batch,
             num_decoder_attention_heads,
             decoder_past_length,
             self._config.hidden_size // num_decoder_attention_heads,
         )
         _lowercase    :   Optional[Any]      =     torch.cat(
             [common_inputs["decoder_attention_mask"], torch.ones(_UpperCamelCase    ,       _UpperCamelCase						)]    ,       dim=1						)
         _lowercase    :   List[str]      =     []
         _lowercase    :   List[Any]      =     self.num_layers

         for _ in range(_UpperCamelCase						):
            common_inputs["past_key_values"].append(
                (
                    torch.zeros(_UpperCamelCase						),
                    torch.zeros(_UpperCamelCase						),
                    torch.zeros(_UpperCamelCase						),
                    torch.zeros(_UpperCamelCase						),
                )						)
      return common_inputs


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase = -1    ,       _UpperCamelCase = -1    ,       _UpperCamelCase = False    ,       _UpperCamelCase = None    ,       )     ->   Dict:





      """simple docstring"""





      _lowercase    :   Tuple      =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
          _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)

      if self.use_past:
         if not is_torch_available():
            raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."						)
         else:
            import torch
         _lowercase    :   Tuple      =     common_inputs["input_ids"].shape
         _lowercase    :   Dict      =     seqlen
         _lowercase    :   int      =     self.num_layers
         _lowercase    :   Dict      =     self.num_attention_heads
         _lowercase    :   Union[str, Any]      =     (
             batch,
             num_encoder_attention_heads,
             past_key_values_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )
         _lowercase    :   Optional[int]      =     common_inputs["attention_mask"].dtype
         _lowercase    :   Optional[int]      =     torch.cat(
             [common_inputs["attention_mask"], torch.ones(_UpperCamelCase    ,       _UpperCamelCase    ,       dtype=_UpperCamelCase						)]    ,       dim=1						)
         _lowercase    :   Any      =     [
             (torch.zeros(_UpperCamelCase						), torch.zeros(_UpperCamelCase						)) for _ in range(_UpperCamelCase						)
         ]
      return common_inputs


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase = -1    ,       _UpperCamelCase = -1    ,       _UpperCamelCase = False    ,       _UpperCamelCase = None    ,       )     ->   Dict:





      """simple docstring"""





      _lowercase    :   Optional[Any]      =     compute_effective_axis_dimension(
          _UpperCamelCase    ,       fixed_dimension=OnnxConfig.default_fixed_batch    ,       num_token_to_add=0						)

      # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
      _lowercase    :   int      =     tokenizer.num_special_tokens_to_add(_UpperCamelCase						)
      _lowercase    :   int      =     compute_effective_axis_dimension(
          _UpperCamelCase    ,       fixed_dimension=OnnxConfig.default_fixed_sequence    ,       num_token_to_add=_UpperCamelCase						)

      # Generate dummy inputs according to compute batch and sequence
      _lowercase    :   Union[str, Any]      =     [" ".join([tokenizer.unk_token]						) * seq_length] * batch_size
      _lowercase    :   List[str]      =     dict(tokenizer(_UpperCamelCase    ,       return_tensors=_UpperCamelCase						)						)
      return common_inputs


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase = -1    ,       _UpperCamelCase = -1    ,       _UpperCamelCase = False    ,       _UpperCamelCase = None    ,       )     ->   List[str]:





      """simple docstring"""





      if self.task in ["default", "seq2seq-lm"]:
         _lowercase    :   List[Any]      =     self._generate_dummy_inputs_for_default_and_seqaseq_lm(
             _UpperCamelCase    ,       batch_size=_UpperCamelCase    ,       seq_length=_UpperCamelCase    ,       is_pair=_UpperCamelCase    ,       framework=_UpperCamelCase						)

      elif self.task == "causal-lm":
         _lowercase    :   Dict      =     self._generate_dummy_inputs_for_causal_lm(
             _UpperCamelCase    ,       batch_size=_UpperCamelCase    ,       seq_length=_UpperCamelCase    ,       is_pair=_UpperCamelCase    ,       framework=_UpperCamelCase						)
      else:
         _lowercase    :   str      =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             _UpperCamelCase    ,       batch_size=_UpperCamelCase    ,       seq_length=_UpperCamelCase    ,       is_pair=_UpperCamelCase    ,       framework=_UpperCamelCase						)

      return common_inputs


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)     ->   Optional[int]:





      """simple docstring"""





      if self.task in ["default", "seq2seq-lm"]:
         _lowercase    :   List[str]      =     super()._flatten_past_key_values_(_UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)
      else:
         _lowercase    :   Tuple      =     super(_UpperCamelCase    ,       self						)._flatten_past_key_values_(
             _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)






   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase						)     ->   Optional[Any]:





      """simple docstring"""





      if direction not in ["inputs", "outputs"]:
         raise ValueError(f'''direction must either be "inputs" or "outputs", but {direction} was given'''						)

      _lowercase    :   Optional[int]      =     "past_key_values" if direction == "inputs" else "present"
      _lowercase    :   Tuple      =     self.num_layers

      _lowercase    :   Optional[int]      =     "past_encoder_sequence"
      _lowercase    :   int      =     "past_decoder_sequence" if direction == "inputs" else "past_decoder_sequence + sequence"

      for i in range(_UpperCamelCase						):
         _lowercase    :   Optional[Any]      =     {0: "batch", 2: decoder_sequence}
         _lowercase    :   Optional[Any]      =     {0: "batch", 2: decoder_sequence}
         _lowercase    :   Union[str, Any]      =     {0: "batch", 2: encoder_sequence}
         _lowercase    :   int      =     {0: "batch", 2: encoder_sequence}









'''simple docstring'''
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      a__						:


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





      """simple docstring"""





      _lowercase    :   List[str]      =     parent
      _lowercase    :   Dict      =     is_training
      _lowercase    :   Optional[Any]      =     batch_size
      _lowercase    :   int      =     image_size
      _lowercase    :   Dict      =     patch_size
      _lowercase    :   Optional[int]      =     num_channels
      _lowercase    :   List[str]      =     max_token_length
      _lowercase    :   int      =     num_character_labels
      _lowercase    :   int      =     num_bpe_labels
      _lowercase    :   int      =     num_wordpiece_labels
      _lowercase    :   Union[str, Any]      =     hidden_size
      _lowercase    :   List[str]      =     num_hidden_layers
      _lowercase    :   int      =     num_attention_heads
      _lowercase    :   Any      =     mlp_ratio
      _lowercase    :   Optional[Any]      =     patch_embeds_hidden_size
      _lowercase    :   Optional[Any]      =     output_hidden_states


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   List[Any]      =     floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]						)
      _lowercase    :   int      =     self.get_config()
      return config, pixel_values


   def 		_lowerCamelCase     (				self						):





      """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 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase						):





      """simple docstring"""





      _lowercase    :   List[str]      =     MgpstrForSceneTextRecognition(_UpperCamelCase						)
      model.to(_UpperCamelCase						)
      model.eval()
      with torch.no_grad():
         _lowercase    :   Tuple      =     model(_UpperCamelCase						)
      self.parent.assertEqual(
          generated_ids[0][0].shape    ,       (self.batch_size, self.max_token_length, self.num_character_labels)						)






   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Optional[int]      =     self.prepare_config_and_inputs()
      _lowercase  ,   _lowercase    :   Optional[int]      =     config_and_inputs
      _lowercase    :   Union[str, Any]      =     {"pixel_values": pixel_values}
      return config, inputs_dict




@require_torch
class      a__						(							lowerCamelCase_						,   lowerCamelCase_						,   unittest.TestCase						):
   _SCREAMING_SNAKE_CASE					:  str			 =							(MgpstrForSceneTextRecognition,) if is_torch_available() else ()
   _SCREAMING_SNAKE_CASE					:  Optional[int]			 =							{'feature-extraction': MgpstrForSceneTextRecognition} if is_torch_available() else {}
   _SCREAMING_SNAKE_CASE					:  List[str]			 =							False

   _SCREAMING_SNAKE_CASE					:  List[Any]			 =							False
   _SCREAMING_SNAKE_CASE					:  Tuple			 =							False
   _SCREAMING_SNAKE_CASE					:  List[str]			 =							False
   _SCREAMING_SNAKE_CASE					:  List[str]			 =							False


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   int      =     MgpstrModelTester(self						)
      _lowercase    :   Optional[Any]      =     ConfigTester(self    ,       config_class=_UpperCamelCase    ,       has_text_modality=_UpperCamelCase						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      self.config_tester.run_common_tests()


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   str      =     self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_UpperCamelCase						)


   @unittest.skip(reason="MgpstrModel does not use inputs_embeds"						)
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      pass


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase  ,   _lowercase    :   str      =     self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _lowercase    :   Optional[int]      =     model_class(_UpperCamelCase						)
         self.assertIsInstance(model.get_input_embeddings()    ,       (nn.Module)						)
         _lowercase    :   Any      =     model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(_UpperCamelCase    ,       nn.Linear						)						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase  ,   _lowercase    :   Any      =     self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _lowercase    :   int      =     model_class(_UpperCamelCase						)
         _lowercase    :   Union[str, Any]      =     inspect.signature(model.forward						)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         _lowercase    :   Optional[int]      =     [*signature.parameters.keys()]

         _lowercase    :   Optional[Any]      =     ["pixel_values"]
         self.assertListEqual(arg_names[:1]    ,       _UpperCamelCase						)


   @unittest.skip(reason="MgpstrModel does not support feedforward chunking"						)
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      pass


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase  ,   _lowercase    :   List[str]      =     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

         _lowercase    :   List[Any]      =     True
         _lowercase    :   int      =     model_class(_UpperCamelCase						)
         self.assertTrue(model.is_gradient_checkpointing						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      def check_hidden_states_output(_UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						):
         _lowercase    :   Dict      =     model_class(_UpperCamelCase						)
         model.to(_UpperCamelCase						)
         model.eval()

         with torch.no_grad():
            _lowercase    :   Dict      =     model(**self._prepare_for_class(_UpperCamelCase    ,       _UpperCamelCase						)						)

         _lowercase    :   int      =     outputs.hidden_states

         _lowercase    :   Any      =     getattr(
             self.model_tester    ,       "expected_num_hidden_layers"    ,       self.model_tester.num_hidden_layers + 1						)
         self.assertEqual(len(_UpperCamelCase						)    ,       _UpperCamelCase						)

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

      _lowercase  ,   _lowercase    :   Optional[int]      =     self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _lowercase    :   Dict      =     True
         check_hidden_states_output(_UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)

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

         check_hidden_states_output(_UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase  ,   _lowercase    :   Union[str, Any]      =     self.model_tester.prepare_config_and_inputs_for_common()

      _lowercase    :   str      =     _config_zero_init(_UpperCamelCase						)
      for model_class in self.all_model_classes:
         _lowercase    :   Union[str, Any]      =     model_class(config=_UpperCamelCase						)
         for name, param in model.named_parameters():
            if isinstance(_UpperCamelCase    ,       (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 		_lowerCamelCase     (				self						):





      """simple docstring"""





      pass







def       _A	(			)    ->			str:
   _lowercase    :   Any      =     "https://i.postimg.cc/ZKwLg2Gw/367-14.png"
   _lowercase    :   Any      =     Image.open(requests.get(snake_case	,							stream=snake_case  ).raw  ).convert("RGB"  )
   return im


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


   @slow
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   int      =     "alibaba-damo/mgp-str-base"
      _lowercase    :   Any      =     MgpstrForSceneTextRecognition.from_pretrained(_UpperCamelCase						).to(_UpperCamelCase						)
      _lowercase    :   List[Any]      =     MgpstrProcessor.from_pretrained(_UpperCamelCase						)

      _lowercase    :   Tuple      =     prepare_img()
      _lowercase    :   Any      =     processor(images=_UpperCamelCase    ,       return_tensors="pt"						).pixel_values.to(_UpperCamelCase						)

      # forward pass
      with torch.no_grad():
         _lowercase    :   Tuple      =     model(_UpperCamelCase						)

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

      _lowercase    :   Tuple      =     processor.batch_decode(outputs.logits						)
      _lowercase    :   Optional[Any]      =     "ticket"

      self.assertEqual(out_strs["generated_text"][0]    ,       _UpperCamelCase						)

      _lowercase    :   Tuple      =     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=_UpperCamelCase    ,       )

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






