

'''simple docstring'''
import collections
import types

import numpy as np

from ..utils import (
    add_end_docstrings,
    is_tensorflow_probability_available,
    is_tf_available,
    is_torch_available,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, ArgumentHandler, Dataset, Pipeline, PipelineException


if is_torch_available():
    import torch

    from ..models.auto.modeling_auto import (
        MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
        MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
    )

if is_tf_available() and is_tensorflow_probability_available():
    import tensorflow as tf
    import tensorflow_probability as tfp

    from ..models.auto.modeling_tf_auto import (
        TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
        TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
    )


class      a__						(							lowerCamelCase_						):


   def __call__(				self    ,       _UpperCamelCase=None    ,       _UpperCamelCase=None    ,       **_UpperCamelCase						):





      """simple docstring"""





      requires_backends(self    ,       "pandas"						)
      import pandas as pd

      if table is None:
         raise ValueError("Keyword argument `table` cannot be None."						)
      elif query is None:
         if isinstance(_UpperCamelCase    ,       _UpperCamelCase						) and table.get("query"						) is not None and table.get("table"						) is not None:
            _lowercase    :   List[str]      =     [table]
         elif isinstance(_UpperCamelCase    ,       _UpperCamelCase						) and len(_UpperCamelCase						) > 0:
            if not all(isinstance(_UpperCamelCase    ,       _UpperCamelCase						) for d in table						):
               raise ValueError(
                   f'''Keyword argument `table` should be a list of dict, but is {(type(_UpperCamelCase						) for d in table)}'''						)

            if table[0].get("query"						) is not None and table[0].get("table"						) is not None:
               _lowercase    :   Union[str, Any]      =     table
            else:
               raise ValueError(
                   "If keyword argument `table` is a list of dictionaries, each dictionary should have a `table`"
                   f''' and `query` key, but only dictionary has keys {table[0].keys()} `table` and `query` keys.'''						)
         elif Dataset is not None and isinstance(_UpperCamelCase    ,       _UpperCamelCase						) or isinstance(_UpperCamelCase    ,       types.GeneratorType						):
            return table
         else:
            raise ValueError(
                "Invalid input. Keyword argument `table` should be either of type `dict` or `list`, but "
                f'''is {type(_UpperCamelCase						)})'''						)
      else:
         _lowercase    :   Union[str, Any]      =     [{"table": table, "query": query}]

      for tqa_pipeline_input in tqa_pipeline_inputs:
         if not isinstance(tqa_pipeline_input["table"]    ,       pd.DataFrame						):
            if tqa_pipeline_input["table"] is None:
               raise ValueError("Table cannot be None."						)

            _lowercase    :   str      =     pd.DataFrame(tqa_pipeline_input["table"]						)

      return tqa_pipeline_inputs




@add_end_docstrings(lowerCamelCase_						)
class      a__						(							lowerCamelCase_						):
   _SCREAMING_SNAKE_CASE					:  Dict			 =							'table,query'


   def __init__(				self    ,       _UpperCamelCase=TableQuestionAnsweringArgumentHandler()    ,       *_UpperCamelCase    ,       **_UpperCamelCase						):





      """simple docstring"""





      super().__init__(*_UpperCamelCase    ,       **_UpperCamelCase						)
      _lowercase    :   List[Any]      =     args_parser

      self.check_model_type(
          dict(
              TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING.items()
              + TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING.items()						)
          if self.framework == "tf"
          else dict(
              MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING.items() + MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING.items()						)						)

      _lowercase    :   Any      =     bool(getattr(self.model.config    ,       "aggregation_labels"    ,       _UpperCamelCase						)						) and bool(
          getattr(self.model.config    ,       "num_aggregation_labels"    ,       _UpperCamelCase						)						)
      _lowercase    :   List[Any]      =     "tapas" if hasattr(self.model.config    ,       "aggregation_labels"						) else None


   def 		_lowerCamelCase     (				self    ,       **_UpperCamelCase						):





      """simple docstring"""





      return self.model(**_UpperCamelCase						)


   def 		_lowerCamelCase     (				self    ,       **_UpperCamelCase						):





      """simple docstring"""





      if self.framework == "pt":
         _lowercase    :   str      =     []
         _lowercase    :   Tuple      =     []
         _lowercase    :   Optional[Any]      =     None
         _lowercase    :   List[str]      =     inputs["input_ids"].shape[0]

         _lowercase    :   int      =     inputs["input_ids"].to(self.device						)
         _lowercase    :   Dict      =     inputs["attention_mask"].to(self.device						)
         _lowercase    :   Tuple      =     inputs["token_type_ids"].to(self.device						)
         _lowercase    :   Optional[Any]      =     None

         for index in range(_UpperCamelCase						):
            # If sequences have already been processed, the token type IDs will be created according to the previous
            # answer.
            if prev_answers is not None:
               _lowercase    :   Optional[Any]      =     token_type_ids_example[:, 3]  # shape (seq_len,)
               _lowercase    :   Any      =     np.zeros_like(prev_labels_example.cpu().numpy()						)  # shape (seq_len,)

               _lowercase    :   Optional[Any]      =     token_type_ids[index]  # shape (seq_len, 7)
               for i in range(model_labels.shape[0]						):
                  _lowercase    :   str      =     token_type_ids_example[:, 0].tolist()[i]
                  _lowercase    :   int      =     token_type_ids_example[:, 1].tolist()[i] - 1
                  _lowercase    :   List[Any]      =     token_type_ids_example[:, 2].tolist()[i] - 1

                  if row_id >= 0 and col_id >= 0 and segment_id == 1:
                     _lowercase    :   Any      =     int(prev_answers[(col_id, row_id)]						)

               _lowercase    :   Optional[int]      =     torch.from_numpy(_UpperCamelCase						).type(torch.long						).to(self.device						)

            _lowercase    :   List[Any]      =     input_ids[index]
            _lowercase    :   int      =     attention_mask[index]  # shape (seq_len,)
            _lowercase    :   List[str]      =     token_type_ids[index]  # shape (seq_len, 7)
            _lowercase    :   str      =     self.model(
                input_ids=input_ids_example.unsqueeze(0						)    ,       attention_mask=attention_mask_example.unsqueeze(0						)    ,       token_type_ids=token_type_ids_example.unsqueeze(0						)    ,       )
            _lowercase    :   Any      =     outputs.logits

            if self.aggregate:
               all_aggregations.append(outputs.logits_aggregation						)

            all_logits.append(_UpperCamelCase						)

            _lowercase    :   Optional[Any]      =     torch.distributions.Bernoulli(logits=_UpperCamelCase						)
            _lowercase    :   str      =     dist_per_token.probs * attention_mask_example.type(torch.floataa						).to(
                dist_per_token.probs.device						)

            _lowercase    :   Any      =     collections.defaultdict(_UpperCamelCase						)
            for i, p in enumerate(probabilities.squeeze().tolist()						):
               _lowercase    :   Optional[int]      =     token_type_ids_example[:, 0].tolist()[i]
               _lowercase    :   Optional[Any]      =     token_type_ids_example[:, 1].tolist()[i] - 1
               _lowercase    :   Tuple      =     token_type_ids_example[:, 2].tolist()[i] - 1
               if col >= 0 and row >= 0 and segment_id == 1:
                  coords_to_probs[(col, row)].append(_UpperCamelCase						)

            _lowercase    :   Dict      =     {key: np.array(coords_to_probs[key]						).mean() > 0.5 for key in coords_to_probs}

         _lowercase    :   Union[str, Any]      =     torch.cat(tuple(_UpperCamelCase						)    ,       0						)

         return (logits_batch,) if not self.aggregate else (logits_batch, torch.cat(tuple(_UpperCamelCase						)    ,       0						))
      else:
         _lowercase    :   List[Any]      =     []
         _lowercase    :   Tuple      =     []
         _lowercase    :   Tuple      =     None
         _lowercase    :   Dict      =     inputs["input_ids"].shape[0]

         _lowercase    :   int      =     inputs["input_ids"]
         _lowercase    :   int      =     inputs["attention_mask"]
         _lowercase    :   Optional[Any]      =     inputs["token_type_ids"].numpy()
         _lowercase    :   Optional[Any]      =     None

         for index in range(_UpperCamelCase						):
            # If sequences have already been processed, the token type IDs will be created according to the previous
            # answer.
            if prev_answers is not None:
               _lowercase    :   Optional[Any]      =     token_type_ids_example[:, 3]  # shape (seq_len,)
               _lowercase    :   str      =     np.zeros_like(_UpperCamelCase    ,       dtype=np.intaa						)  # shape (seq_len,)

               _lowercase    :   Dict      =     token_type_ids[index]  # shape (seq_len, 7)
               for i in range(model_labels.shape[0]						):
                  _lowercase    :   Optional[int]      =     token_type_ids_example[:, 0].tolist()[i]
                  _lowercase    :   Optional[Any]      =     token_type_ids_example[:, 1].tolist()[i] - 1
                  _lowercase    :   List[str]      =     token_type_ids_example[:, 2].tolist()[i] - 1

                  if row_id >= 0 and col_id >= 0 and segment_id == 1:
                     _lowercase    :   Optional[Any]      =     int(prev_answers[(col_id, row_id)]						)

               _lowercase    :   List[Any]      =     model_labels

            _lowercase    :   int      =     input_ids[index]
            _lowercase    :   int      =     attention_mask[index]  # shape (seq_len,)
            _lowercase    :   Tuple      =     token_type_ids[index]  # shape (seq_len, 7)
            _lowercase    :   Any      =     self.model(
                input_ids=np.expand_dims(_UpperCamelCase    ,       axis=0						)    ,       attention_mask=np.expand_dims(_UpperCamelCase    ,       axis=0						)    ,       token_type_ids=np.expand_dims(_UpperCamelCase    ,       axis=0						)    ,       )
            _lowercase    :   Tuple      =     outputs.logits

            if self.aggregate:
               all_aggregations.append(outputs.logits_aggregation						)

            all_logits.append(_UpperCamelCase						)

            _lowercase    :   Optional[int]      =     tfp.distributions.Bernoulli(logits=_UpperCamelCase						)
            _lowercase    :   Optional[Any]      =     dist_per_token.probs_parameter() * tf.cast(_UpperCamelCase    ,       tf.floataa						)

            _lowercase    :   Optional[int]      =     collections.defaultdict(_UpperCamelCase						)
            _lowercase    :   str      =     token_type_ids_example
            for i, p in enumerate(tf.squeeze(_UpperCamelCase						).numpy().tolist()						):
               _lowercase    :   Optional[Any]      =     token_type_ids_example[:, 0].tolist()[i]
               _lowercase    :   List[Any]      =     token_type_ids_example[:, 1].tolist()[i] - 1
               _lowercase    :   List[Any]      =     token_type_ids_example[:, 2].tolist()[i] - 1
               if col >= 0 and row >= 0 and segment_id == 1:
                  coords_to_probs[(col, row)].append(_UpperCamelCase						)

            _lowercase    :   Any      =     {key: np.array(coords_to_probs[key]						).mean() > 0.5 for key in coords_to_probs}

         _lowercase    :   Union[str, Any]      =     tf.concat(tuple(_UpperCamelCase						)    ,       0						)

         return (logits_batch,) if not self.aggregate else (logits_batch, tf.concat(tuple(_UpperCamelCase						)    ,       0						))


   def __call__(				self    ,       *_UpperCamelCase    ,       **_UpperCamelCase						):





      """simple docstring"""





      _lowercase    :   Dict      =     self._args_parser(*_UpperCamelCase    ,       **_UpperCamelCase						)

      _lowercase    :   Tuple      =     super().__call__(_UpperCamelCase    ,       **_UpperCamelCase						)
      if len(_UpperCamelCase						) == 1:
         return results[0]
      return results


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase=None    ,       _UpperCamelCase=None    ,       _UpperCamelCase=None    ,       **_UpperCamelCase						):





      """simple docstring"""





      _lowercase    :   str      =     {}
      if padding is not None:
         _lowercase    :   int      =     padding
      if truncation is not None:
         _lowercase    :   str      =     truncation

      _lowercase    :   Any      =     {}
      if sequential is not None:
         _lowercase    :   Dict      =     sequential
      return preprocess_params, forward_params, {}


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase=None    ,       _UpperCamelCase=True    ,       _UpperCamelCase=None						):





      """simple docstring"""





      if truncation is None:
         if self.type == "tapas":
            _lowercase    :   Dict      =     "drop_rows_to_fit"
         else:
            _lowercase    :   Optional[int]      =     "do_not_truncate"

      _lowercase  ,   _lowercase    :   Any      =     pipeline_input["table"], pipeline_input["query"]
      if table.empty:
         raise ValueError("table is empty"						)
      if query is None or query == "":
         raise ValueError("query is empty"						)
      _lowercase    :   Any      =     self.tokenizer(_UpperCamelCase    ,       _UpperCamelCase    ,       return_tensors=self.framework    ,       truncation=_UpperCamelCase    ,       padding=_UpperCamelCase						)
      _lowercase    :   List[Any]      =     table
      return inputs


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase=False						):





      """simple docstring"""





      _lowercase    :   Dict      =     model_inputs.pop("table"						)

      if self.type == "tapas":
         if sequential:
            _lowercase    :   Tuple      =     self.sequential_inference(**_UpperCamelCase						)
         else:
            _lowercase    :   Any      =     self.batch_inference(**_UpperCamelCase						)
      else:
         _lowercase    :   Tuple      =     self.model.generate(**_UpperCamelCase						)
      _lowercase    :   Union[str, Any]      =     {"model_inputs": model_inputs, "table": table, "outputs": outputs}
      return model_outputs






   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase						):





      """simple docstring"""





      _lowercase    :   Dict      =     model_outputs["model_inputs"]
      _lowercase    :   Union[str, Any]      =     model_outputs["table"]
      _lowercase    :   Dict      =     model_outputs["outputs"]
      if self.type == "tapas":
         if self.aggregate:
            _lowercase  ,   _lowercase    :   Union[str, Any]      =     outputs[:2]
            _lowercase    :   List[Any]      =     self.tokenizer.convert_logits_to_predictions(_UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						)
            _lowercase  ,   _lowercase    :   List[Any]      =     predictions
            _lowercase    :   Any      =     {i: self.model.config.aggregation_labels[pred] for i, pred in enumerate(_UpperCamelCase						)}

            _lowercase    :   Dict      =     self.model.config.no_aggregation_label_index
            _lowercase    :   str      =     {
                i: aggregators[i] + " > " for i, pred in enumerate(_UpperCamelCase						) if pred != no_agg_label_index
            }
         else:
            _lowercase    :   Any      =     outputs[0]
            _lowercase    :   str      =     self.tokenizer.convert_logits_to_predictions(_UpperCamelCase    ,       _UpperCamelCase						)
            _lowercase    :   Union[str, Any]      =     predictions[0]
            _lowercase    :   str      =     {}
            _lowercase    :   Optional[Any]      =     {}
         _lowercase    :   Optional[Any]      =     []
         for index, coordinates in enumerate(_UpperCamelCase						):
            _lowercase    :   List[str]      =     [table.iat[coordinate] for coordinate in coordinates]
            _lowercase    :   str      =     aggregators.get(_UpperCamelCase    ,       ""						)
            _lowercase    :   Dict      =     aggregators_prefix.get(_UpperCamelCase    ,       ""						)
            _lowercase    :   List[str]      =     {
                "answer": aggregator_prefix + ", ".join(_UpperCamelCase						),
                "coordinates": coordinates,
                "cells": [table.iat[coordinate] for coordinate in coordinates],
            }
            if aggregator:
               _lowercase    :   Tuple      =     aggregator

            answers.append(_UpperCamelCase						)
         if len(_UpperCamelCase						) == 0:
            raise PipelineException("Empty answer"						)
      else:
         _lowercase    :   List[Any]      =     [{"answer": answer} for answer in self.tokenizer.batch_decode(_UpperCamelCase    ,       skip_special_tokens=_UpperCamelCase						)]

      return answers if len(_UpperCamelCase						) > 1 else answers[0]









'''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						)						)






