



"""simple docstring"""





import unittest

from transformers import TrOCRConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM



@require_torch
class    _lowerCAmelCase    :





		"""simple docstring"""






		def __init__(					self							,    _lowercase							,    _lowercase=9_9							,    _lowercase=1_3							,    _lowercase=1_6							,    _lowercase=7							,    _lowercase=True							,    _lowercase=True							,    _lowercase=True							,    _lowercase=False							,    _lowercase=True							,    _lowercase=2							,    _lowercase=3_2							,    _lowercase=4							,    _lowercase=4							,    _lowercase=3_0							,    _lowercase=0							,    _lowercase=1							,    _lowercase=2							,    _lowercase=None							,    ) ->						List[Any]:







								'''simple docstring'''

								snake_case_   : str						=			parent
								snake_case_   : Dict						=			batch_size
								snake_case_   : Optional[Any]						=			decoder_seq_length
								# For common tests
								snake_case_   : int						=			self.decoder_seq_length
								snake_case_   : Optional[Any]						=			is_training
								snake_case_   : List[Any]						=			use_attention_mask
								snake_case_   : Dict						=			use_labels

								snake_case_   : Union[str, Any]						=			vocab_size
								snake_case_   : Optional[int]						=			d_model
								snake_case_   : Union[str, Any]						=			d_model
								snake_case_   : Dict						=			decoder_layers
								snake_case_   : List[Any]						=			decoder_layers
								snake_case_   : List[str]						=			decoder_ffn_dim
								snake_case_   : List[str]						=			decoder_attention_heads
								snake_case_   : Dict						=			decoder_attention_heads
								snake_case_   : Any						=			eos_token_id
								snake_case_   : List[Any]						=			bos_token_id
								snake_case_   : str						=			pad_token_id
								snake_case_   : List[Any]						=			decoder_start_token_id
								snake_case_   : int						=			use_cache
								snake_case_   : Optional[int]						=			max_position_embeddings

								snake_case_   : Tuple						=			None
								snake_case_   : List[str]						=			decoder_seq_length
								snake_case_   : Dict						=			2
								snake_case_   : str						=			1





		def    UpperCAmelCase__							(					self   ) ->						List[str]:







								'''simple docstring'''

								snake_case_   : List[str]						=			ids_tensor([self.batch_size, self.decoder_seq_length]							,    self.vocab_size   )

								snake_case_   : List[Any]						=			None
								if self.use_attention_mask:
														snake_case_   : Tuple						=			ids_tensor([self.batch_size, self.decoder_seq_length]							,    vocab_size=2   )

								snake_case_   : Any						=			None
								if self.use_labels:
														snake_case_   : List[Any]						=			ids_tensor([self.batch_size, self.decoder_seq_length]							,    self.vocab_size   )

								snake_case_   : int						=			TrOCRConfig(
								    vocab_size=self.vocab_size							,    d_model=self.d_model							,    decoder_layers=self.decoder_layers							,    decoder_ffn_dim=self.decoder_ffn_dim							,    decoder_attention_heads=self.decoder_attention_heads							,    eos_token_id=self.eos_token_id							,    bos_token_id=self.bos_token_id							,    use_cache=self.use_cache							,    pad_token_id=self.pad_token_id							,    decoder_start_token_id=self.decoder_start_token_id							,    max_position_embeddings=self.max_position_embeddings							,    )

								return (config, input_ids, attention_mask, lm_labels)





		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    ) ->						Dict:







								'''simple docstring'''

								snake_case_   : Any						=			True
								snake_case_   : Optional[Any]						=			TrOCRDecoder(config=_lowercase   ).to(_lowercase   ).eval()
								snake_case_   : Union[str, Any]						=			input_ids[:2]

								input_ids[input_ids == 0] += 1
								# first forward pass
								snake_case_   : str						=			model(_lowercase							,    use_cache=_lowercase   )
								snake_case_   : Optional[Any]						=			model(_lowercase   )
								snake_case_   : List[Any]						=			model(_lowercase							,    use_cache=_lowercase   )

								self.parent.assertTrue(len(_lowercase   ) == len(_lowercase   )   )
								self.parent.assertTrue(len(_lowercase   ) == len(_lowercase   ) + 1   )

								snake_case_   : int						=			outputs["""past_key_values"""]

								# create hypothetical next token and extent to next_input_ids
								snake_case_   : Union[str, Any]						=			ids_tensor((2, 1)							,    config.vocab_size - 1   ) + 1

								# append to next input_ids and
								snake_case_   : str						=			torch.cat([input_ids, next_tokens]							,    dim=-1   )

								snake_case_   : str						=			model(_lowercase   )["""last_hidden_state"""]
								snake_case_   : List[str]						=			model(_lowercase							,    past_key_values=_lowercase   )["""last_hidden_state"""]

								# select random slice
								snake_case_   : Union[str, Any]						=			ids_tensor((1,)							,    output_from_past.shape[-1]   ).item()
								snake_case_   : Tuple						=			output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
								snake_case_   : Tuple						=			output_from_past[:, 0, random_slice_idx].detach()

								# test that outputs are equal for slice
								assert torch.allclose(_lowercase							,    _lowercase							,    atol=1E-3   )





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







								'''simple docstring'''

								snake_case_   : Any						=			self.prepare_config_and_inputs()
								snake_case_			,		snake_case_			,		snake_case_			,		snake_case_   : List[Any]						=			config_and_inputs

								snake_case_   : Union[str, Any]						=			{"""input_ids""": input_ids, """attention_mask""": attention_mask}
								return config, inputs_dict




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





		"""simple docstring"""






		_lowerCamelCase			  =       (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
		_lowerCamelCase			  =       (TrOCRForCausalLM,) if is_torch_available() else ()
		_lowerCamelCase			  =       {'''text-generation''': TrOCRForCausalLM} if is_torch_available() else {}
		_lowerCamelCase			  =       True
		_lowerCamelCase			  =       False





		def    UpperCAmelCase__							(					self   ) ->						Optional[Any]:







								'''simple docstring'''

								snake_case_   : Tuple						=			TrOCRStandaloneDecoderModelTester(self							,    is_training=_lowercase   )
								snake_case_   : str						=			ConfigTester(self							,    config_class=_lowercase   )





		def    UpperCAmelCase__							(					self   ) ->						List[str]:







								'''simple docstring'''

								pass





		def    UpperCAmelCase__							(					self   ) ->						List[str]:







								'''simple docstring'''

								pass





		def    UpperCAmelCase__							(					self   ) ->						Tuple:







								'''simple docstring'''

								pass





		def    UpperCAmelCase__							(					self   ) ->						Tuple:







								'''simple docstring'''

								self.config_tester.run_common_tests()





		def    UpperCAmelCase__							(					self   ) ->						List[str]:







								'''simple docstring'''

								snake_case_   : Optional[Any]						=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_decoder_model_past(*_lowercase   )





		def    UpperCAmelCase__							(					self   ) ->						Tuple:







								'''simple docstring'''

								return





		@unittest.skip("""The model doesn't support left padding"""   )  # and it's not used enough to be worth fixing :)
		def    UpperCAmelCase__							(					self   ) ->						int:







								'''simple docstring'''

								pass






"""simple docstring"""





from sklearn.metrics import fa_score, matthews_corrcoef

import datasets

from .record_evaluation import evaluate as evaluate_record


__lowerCAmelCase       :					List[str]      					=					'''\
@article{wang2019superglue,
  title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems},
  author={Wang, Alex and Pruksachatkun, Yada and Nangia, Nikita and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R},
  journal={arXiv preprint arXiv:1905.00537},
  year={2019}
}
'''

__lowerCAmelCase       :					Optional[Any]      					=					'''\
SuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after
GLUE with a new set of more difficult language understanding tasks, improved
resources, and a new public leaderboard.
'''

__lowerCAmelCase       :					str      					=					'''
Compute SuperGLUE evaluation metric associated to each SuperGLUE dataset.
Args:
    predictions: list of predictions to score. Depending on the SuperGlUE subset:
        - for \'record\': list of question-answer dictionaries with the following keys:
            - \'idx\': index of the question as specified by the dataset
            - \'prediction_text\': the predicted answer text
        - for \'multirc\': list of question-answer dictionaries with the following keys:
            - \'idx\': index of the question-answer pair as specified by the dataset
            - \'prediction\': the predicted answer label
        - otherwise: list of predicted labels
    references: list of reference labels. Depending on the SuperGLUE subset:
        - for \'record\': list of question-answers dictionaries with the following keys:
            - \'idx\': index of the question as specified by the dataset
            - \'answers\': list of possible answers
        - otherwise: list of reference labels
Returns: depending on the SuperGLUE subset:
    - for \'record\':
        - \'exact_match\': Exact match between answer and gold answer
        - \'f1\': F1 score
    - for \'multirc\':
        - \'exact_match\': Exact match between answer and gold answer
        - \'f1_m\': Per-question macro-F1 score
        - \'f1_a\': Average F1 score over all answers
    - for \'axb\':
        \'matthews_correlation\': Matthew Correlation
    - for \'cb\':
        - \'accuracy\': Accuracy
        - \'f1\': F1 score
    - for all others:
        - \'accuracy\': Accuracy
Examples:

    >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'copa\')  # any of ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]
    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0}

    >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'cb\')
    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0, \'f1\': 1.0}

    >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'record\')
    >>> predictions = [{\'idx\': {\'passage\': 0, \'query\': 0}, \'prediction_text\': \'answer\'}]
    >>> references = [{\'idx\': {\'passage\': 0, \'query\': 0}, \'answers\': [\'answer\', \'another_answer\']}]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'exact_match\': 1.0, \'f1\': 1.0}

    >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'multirc\')
    >>> predictions = [{\'idx\': {\'answer\': 0, \'paragraph\': 0, \'question\': 0}, \'prediction\': 0}, {\'idx\': {\'answer\': 1, \'paragraph\': 2, \'question\': 3}, \'prediction\': 1}]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'exact_match\': 1.0, \'f1_m\': 1.0, \'f1_a\': 1.0}

    >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'axb\')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'matthews_correlation\': 1.0}
'''
def 	__lowerCAmelCase						(		__UpperCamelCase      :			List[str]					, __UpperCamelCase      :			Any    ):


						'''simple docstring'''






						return float((preds == labels).mean()    )
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Any					, __UpperCamelCase      :			Optional[int]					, __UpperCamelCase      :			str="binary"    ):


						'''simple docstring'''






						snake_case_   : Optional[Any]						=			simple_accuracy(__UpperCamelCase					, __UpperCamelCase    )
						snake_case_   : Dict						=			float(fa_score(y_true=__UpperCamelCase					, y_pred=__UpperCamelCase					, average=__UpperCamelCase    )    )
						return {
						    "accuracy": acc,
						    "f1": fa,
						}
def 	__lowerCAmelCase						(		__UpperCamelCase      :			str					, __UpperCamelCase      :			int    ):


						'''simple docstring'''






						snake_case_   : List[Any]						=			{}
						for id_pred, label in zip(__UpperCamelCase					, __UpperCamelCase    ):
												snake_case_   : Optional[int]						=			F'{id_pred["idx"]["paragraph"]}-{id_pred["idx"]["question"]}'
												snake_case_   : Union[str, Any]						=			id_pred["""prediction"""]
												if question_id in question_map:
																		question_map[question_id].append((pred, label)    )
												else:
																		snake_case_   : str						=			[(pred, label)]
						snake_case_			,		snake_case_   : List[str]						=			[], []
						for question, preds_labels in question_map.items():
												snake_case_			,		snake_case_   : Optional[Any]						=			zip(*__UpperCamelCase    )
												snake_case_   : int						=			fa_score(y_true=__UpperCamelCase					, y_pred=__UpperCamelCase					, average="""macro"""    )
												fas.append(__UpperCamelCase    )
												snake_case_   : Dict						=			int(sum(pred == label for pred, label in preds_labels    ) == len(__UpperCamelCase    )    )
												ems.append(__UpperCamelCase    )
						snake_case_   : Optional[int]						=			float(sum(__UpperCamelCase    ) / len(__UpperCamelCase    )    )
						snake_case_   : Any						=			sum(__UpperCamelCase    ) / len(__UpperCamelCase    )
						snake_case_   : int						=			float(fa_score(y_true=__UpperCamelCase					, y_pred=[id_pred["""prediction"""] for id_pred in ids_preds]    )    )
						return {"exact_match": em, "f1_m": fa_m, "f1_a": fa_a}






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,				_KWARGS_DESCRIPTION		)
class    _lowerCAmelCase    (				datasets.Metric		):





		"""simple docstring"""






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







								'''simple docstring'''

								if self.config_name not in [
								    "boolq",
								    "cb",
								    "copa",
								    "multirc",
								    "record",
								    "rte",
								    "wic",
								    "wsc",
								    "wsc.fixed",
								    "axb",
								    "axg",
								]:
														raise KeyError(
														    """You should supply a configuration name selected in """
														    """[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]"""   )
								return datasets.MetricInfo(
								    description=_DESCRIPTION							,    citation=_CITATION							,    inputs_description=_KWARGS_DESCRIPTION							,    features=datasets.Features(self._get_feature_types()   )							,    codebase_urls=[]							,    reference_urls=[]							,    format="""numpy""" if not self.config_name == """record""" and not self.config_name == """multirc""" else None							,    )





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







								'''simple docstring'''

								if self.config_name == "record":
														return {
														    "predictions": {
														        "idx": {
														            "passage": datasets.Value("""int64"""   ),
														            "query": datasets.Value("""int64"""   ),
														        },
														        "prediction_text": datasets.Value("""string"""   ),
														    },
														    "references": {
														        "idx": {
														            "passage": datasets.Value("""int64"""   ),
														            "query": datasets.Value("""int64"""   ),
														        },
														        "answers": datasets.Sequence(datasets.Value("""string"""   )   ),
														    },
														}
								elif self.config_name == "multirc":
														return {
														    "predictions": {
														        "idx": {
														            "answer": datasets.Value("""int64"""   ),
														            "paragraph": datasets.Value("""int64"""   ),
														            "question": datasets.Value("""int64"""   ),
														        },
														        "prediction": datasets.Value("""int64"""   ),
														    },
														    "references": datasets.Value("""int64"""   ),
														}
								else:
														return {
														    "predictions": datasets.Value("""int64"""   ),
														    "references": datasets.Value("""int64"""   ),
														}





		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase   ) ->						List[str]:







								'''simple docstring'''

								if self.config_name == "axb":
														return {"matthews_correlation": matthews_corrcoef(_lowercase							,    _lowercase   )}
								elif self.config_name == "cb":
														return acc_and_fa(_lowercase							,    _lowercase							,    fa_avg="""macro"""   )
								elif self.config_name == "record":
														snake_case_   : Optional[Any]						=			[
														    {
														        """qas""": [
														            {"""id""": ref["""idx"""]["""query"""], """answers""": [{"""text""": ans} for ans in ref["""answers"""]]}
														            for ref in references
														        ]
														    }
														]
														snake_case_   : Dict						=			{pred["""idx"""]["""query"""]: pred["""prediction_text"""] for pred in predictions}
														return evaluate_record(_lowercase							,    _lowercase   )[0]
								elif self.config_name == "multirc":
														return evaluate_multirc(_lowercase							,    _lowercase   )
								elif self.config_name in ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]:
														return {"accuracy": simple_accuracy(_lowercase							,    _lowercase   )}
								else:
														raise KeyError(
														    """You should supply a configuration name selected in """
														    """[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]"""   )

