



"""simple docstring"""





import gc
import unittest

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

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


if is_torch_available():
					import torch

					from transformers import (
					    CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
					    CTRLForSequenceClassification,
					    CTRLLMHeadModel,
					    CTRLModel,
					)



class    _lowerCAmelCase    :





		"""simple docstring"""






		def __init__(					self							,    _lowercase							,    _lowercase=1_4							,    _lowercase=7							,    _lowercase=True							,    _lowercase=True							,    _lowercase=True							,    _lowercase=True							,    _lowercase=True							,    _lowercase=9_9							,    _lowercase=3_2							,    _lowercase=5							,    _lowercase=4							,    _lowercase=3_7							,    _lowercase="gelu"							,    _lowercase=0.1							,    _lowercase=0.1							,    _lowercase=5_1_2							,    _lowercase=1_6							,    _lowercase=2							,    _lowercase=0.02							,    _lowercase=3							,    _lowercase=4							,    _lowercase=None							,    ) ->						List[Any]:







								'''simple docstring'''

								snake_case_   : int						=			parent
								snake_case_   : str						=			batch_size
								snake_case_   : Dict						=			seq_length
								snake_case_   : Dict						=			is_training
								snake_case_   : List[str]						=			use_token_type_ids
								snake_case_   : Dict						=			use_input_mask
								snake_case_   : Tuple						=			use_labels
								snake_case_   : int						=			use_mc_token_ids
								snake_case_   : List[Any]						=			vocab_size
								snake_case_   : List[Any]						=			hidden_size
								snake_case_   : Any						=			num_hidden_layers
								snake_case_   : str						=			num_attention_heads
								snake_case_   : str						=			intermediate_size
								snake_case_   : Optional[int]						=			hidden_act
								snake_case_   : int						=			hidden_dropout_prob
								snake_case_   : Optional[int]						=			attention_probs_dropout_prob
								snake_case_   : List[Any]						=			max_position_embeddings
								snake_case_   : Any						=			type_vocab_size
								snake_case_   : Optional[Any]						=			type_sequence_label_size
								snake_case_   : int						=			initializer_range
								snake_case_   : Union[str, Any]						=			num_labels
								snake_case_   : Dict						=			num_choices
								snake_case_   : int						=			scope
								snake_case_   : str						=			self.vocab_size - 1





		def    UpperCAmelCase__							(					self   ) ->						int:







								'''simple docstring'''

								snake_case_   : int						=			ids_tensor([self.batch_size, self.seq_length]							,    self.vocab_size   )

								snake_case_   : int						=			None
								if self.use_input_mask:
														snake_case_   : Optional[int]						=			random_attention_mask([self.batch_size, self.seq_length]   )

								snake_case_   : Tuple						=			None
								if self.use_token_type_ids:
														snake_case_   : List[Any]						=			ids_tensor([self.batch_size, self.seq_length]							,    self.type_vocab_size   )

								snake_case_   : Optional[Any]						=			None
								if self.use_mc_token_ids:
														snake_case_   : Optional[int]						=			ids_tensor([self.batch_size, self.num_choices]							,    self.seq_length   )

								snake_case_   : Any						=			None
								snake_case_   : Any						=			None
								snake_case_   : Optional[Any]						=			None
								if self.use_labels:
														snake_case_   : Union[str, Any]						=			ids_tensor([self.batch_size]							,    self.type_sequence_label_size   )
														snake_case_   : Optional[int]						=			ids_tensor([self.batch_size, self.seq_length]							,    self.num_labels   )
														snake_case_   : Any						=			ids_tensor([self.batch_size]							,    self.num_choices   )

								snake_case_   : List[Any]						=			self.get_config()

								snake_case_   : List[Any]						=			ids_tensor([self.num_hidden_layers, self.num_attention_heads]							,    2   )

								return (
								    config,
								    input_ids,
								    input_mask,
								    head_mask,
								    token_type_ids,
								    mc_token_ids,
								    sequence_labels,
								    token_labels,
								    choice_labels,
								)





		def    UpperCAmelCase__							(					self   ) ->						Tuple:







								'''simple docstring'''

								return CTRLConfig(
								    vocab_size=self.vocab_size							,    n_embd=self.hidden_size							,    n_layer=self.num_hidden_layers							,    n_head=self.num_attention_heads							,    n_positions=self.max_position_embeddings							,    pad_token_id=self.pad_token_id							,    )





		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    *_lowercase   ) ->						Union[str, Any]:







								'''simple docstring'''

								snake_case_   : int						=			CTRLModel(config=_lowercase   )
								model.to(_lowercase   )
								model.eval()

								model(_lowercase							,    token_type_ids=_lowercase							,    head_mask=_lowercase   )
								model(_lowercase							,    token_type_ids=_lowercase   )
								snake_case_   : List[Any]						=			model(_lowercase   )
								self.parent.assertEqual(result.last_hidden_state.shape							,    (self.batch_size, self.seq_length, self.hidden_size)   )
								self.parent.assertEqual(len(result.past_key_values   )							,    config.n_layer   )





		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    *_lowercase   ) ->						int:







								'''simple docstring'''

								snake_case_   : Tuple						=			CTRLLMHeadModel(_lowercase   )
								model.to(_lowercase   )
								model.eval()

								snake_case_   : Optional[int]						=			model(_lowercase							,    token_type_ids=_lowercase							,    labels=_lowercase   )
								self.parent.assertEqual(result.loss.shape							,    ()   )
								self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.seq_length, self.vocab_size)   )





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







								'''simple docstring'''

								snake_case_   : Union[str, Any]						=			self.prepare_config_and_inputs()

								(
								    (
								    snake_case_
								)			,		(
								    snake_case_
								)			,		(
								    snake_case_
								)			,		(
								    snake_case_
								)			,		(
								    snake_case_
								)			,		(
								    snake_case_
								)			,		(
								    snake_case_
								)			,		(
								    snake_case_
								)			,		(
								    snake_case_
								)			,		
								)   : List[Any]						=			config_and_inputs

								snake_case_   : List[str]						=			{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """head_mask""": head_mask}

								return config, inputs_dict





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







								'''simple docstring'''

								snake_case_   : str						=			self.num_labels
								snake_case_   : str						=			CTRLForSequenceClassification(_lowercase   )
								model.to(_lowercase   )
								model.eval()
								snake_case_   : Dict						=			ids_tensor([self.batch_size]							,    self.type_sequence_label_size   )
								snake_case_   : List[str]						=			model(_lowercase							,    token_type_ids=_lowercase							,    labels=_lowercase   )
								self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_labels)   )




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





		"""simple docstring"""






		_lowerCamelCase			  =       (CTRLModel, CTRLLMHeadModel, CTRLForSequenceClassification) if is_torch_available() else ()
		_lowerCamelCase			  =       (CTRLLMHeadModel,) if is_torch_available() else ()
		_lowerCamelCase			  =       (
		    {
		        '''feature-extraction''': CTRLModel,
		        '''text-classification''': CTRLForSequenceClassification,
		        '''text-generation''': CTRLLMHeadModel,
		        '''zero-shot''': CTRLForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		_lowerCamelCase			  =       True
		_lowerCamelCase			  =       False
		_lowerCamelCase			  =       False





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







								'''simple docstring'''

								if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
														# Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
														# `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
														# config could not be created.
														return True

								return False





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







								'''simple docstring'''

								snake_case_   : Tuple						=			CTRLModelTester(self   )
								snake_case_   : Dict						=			ConfigTester(self							,    config_class=_lowercase							,    n_embd=3_7   )





		def    UpperCAmelCase__							(					self   ) ->						Any:







								'''simple docstring'''

								super().tearDown()
								# clean-up as much as possible GPU memory occupied by PyTorch
								gc.collect()
								torch.cuda.empty_cache()





		def    UpperCAmelCase__							(					self   ) ->						Union[str, Any]:







								'''simple docstring'''

								self.config_tester.run_common_tests()





		def    UpperCAmelCase__							(					self   ) ->						Union[str, Any]:







								'''simple docstring'''

								snake_case_   : Union[str, Any]						=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_ctrl_model(*_lowercase   )





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







								'''simple docstring'''

								snake_case_   : Dict						=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_lm_head_model(*_lowercase   )





		@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""   )
		def    UpperCAmelCase__							(					self   ) ->						List[Any]:







								'''simple docstring'''

								pass





		@slow
		def    UpperCAmelCase__							(					self   ) ->						str:







								'''simple docstring'''

								for model_name in CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														snake_case_   : List[str]						=			CTRLModel.from_pretrained(_lowercase   )
														self.assertIsNotNone(_lowercase   )





		@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




@require_torch
class    _lowerCAmelCase    (				unittest.TestCase		):





		"""simple docstring"""






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







								'''simple docstring'''

								super().tearDown()
								# clean-up as much as possible GPU memory occupied by PyTorch
								gc.collect()
								torch.cuda.empty_cache()





		@slow
		def    UpperCAmelCase__							(					self   ) ->						Union[str, Any]:







								'''simple docstring'''

								snake_case_   : Optional[Any]						=			CTRLLMHeadModel.from_pretrained("""ctrl"""   )
								model.to(_lowercase   )
								snake_case_   : List[str]						=			torch.tensor(
								    [[1_1_8_5_9, 0, 1_6_1_1, 8]]							,    dtype=torch.long							,    device=_lowercase   )  # Legal the president is
								snake_case_   : Union[str, Any]						=			[
								    1_1_8_5_9,
								    0,
								    1_6_1_1,
								    8,
								    5,
								    1_5_0,
								    2_6_4_4_9,
								    2,
								    1_9,
								    3_4_8,
								    4_6_9,
								    3,
								    2_5_9_5,
								    4_8,
								    2_0_7_4_0,
								    2_4_6_5_3_3,
								    2_4_6_5_3_3,
								    1_9,
								    3_0,
								    5,
								]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

								snake_case_   : Optional[Any]						=			model.generate(_lowercase							,    do_sample=_lowercase   )
								self.assertListEqual(output_ids[0].tolist()							,    _lowercase   )






"""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\",]"""   )

