





from sklearn.metrics import fa_score, matthews_corrcoef

import datasets

from .record_evaluation import evaluate as evaluate_record


UpperCAmelCase     :     Optional[int]							=	"\\n@article{wang2019superglue,\n  title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems},\n  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},\n  journal={arXiv preprint arXiv:1905.00537},\n  year={2019}\n}\n"

UpperCAmelCase     :     str							=	"\\nSuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after\nGLUE with a new set of more difficult language understanding tasks, improved\nresources, and a new public leaderboard.\n"

UpperCAmelCase     :     Any							=	"\nCompute SuperGLUE evaluation metric associated to each SuperGLUE dataset.\nArgs:\n    predictions: list of predictions to score. Depending on the SuperGlUE subset:\n        - for 'record': list of question-answer dictionaries with the following keys:\n            - 'idx': index of the question as specified by the dataset\n            - 'prediction_text': the predicted answer text\n        - for 'multirc': list of question-answer dictionaries with the following keys:\n            - 'idx': index of the question-answer pair as specified by the dataset\n            - 'prediction': the predicted answer label\n        - otherwise: list of predicted labels\n    references: list of reference labels. Depending on the SuperGLUE subset:\n        - for 'record': list of question-answers dictionaries with the following keys:\n            - 'idx': index of the question as specified by the dataset\n            - 'answers': list of possible answers\n        - otherwise: list of reference labels\nReturns: depending on the SuperGLUE subset:\n    - for 'record':\n        - 'exact_match': Exact match between answer and gold answer\n        - 'f1': F1 score\n    - for 'multirc':\n        - 'exact_match': Exact match between answer and gold answer\n        - 'f1_m': Per-question macro-F1 score\n        - 'f1_a': Average F1 score over all answers\n    - for 'axb':\n        'matthews_correlation': Matthew Correlation\n    - for 'cb':\n        - 'accuracy': Accuracy\n        - 'f1': F1 score\n    - for all others:\n        - 'accuracy': Accuracy\nExamples:\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'copa')  # any of [\"copa\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"boolq\", \"axg\"]\n    >>> predictions = [0, 1]\n    >>> references = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'cb')\n    >>> predictions = [0, 1]\n    >>> references = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'record')\n    >>> predictions = [{'idx': {'passage': 0, 'query': 0}, 'prediction_text': 'answer'}]\n    >>> references = [{'idx': {'passage': 0, 'query': 0}, 'answers': ['answer', 'another_answer']}]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 1.0, 'f1': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'multirc')\n    >>> predictions = [{'idx': {'answer': 0, 'paragraph': 0, 'question': 0}, 'prediction': 0}, {'idx': {'answer': 1, 'paragraph': 2, 'question': 3}, 'prediction': 1}]\n    >>> references = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 1.0, 'f1_m': 1.0, 'f1_a': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'axb')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'matthews_correlation': 1.0}\n"
def 					_A	(		SCREAMING_SNAKE_CASE					:       Optional[Any]	,	SCREAMING_SNAKE_CASE					:       Any						):





  """simple docstring"""



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





  """simple docstring"""



  a__     : str  =simple_accuracy(_UpperCAmelCase	,	_UpperCAmelCase						)
  a__     : str  =float(fa_score(y_true=_UpperCAmelCase	,	y_pred=_UpperCAmelCase	,	average=_UpperCAmelCase						)						)
  return {
      "accuracy": acc,
      "f1": fa,
  }
def 					_A	(		SCREAMING_SNAKE_CASE					:       List[Any]	,	SCREAMING_SNAKE_CASE					:       Union[str, Any]						):





  """simple docstring"""



  a__     : List[Any]  ={}
  for id_pred, label in zip(_UpperCAmelCase	,	_UpperCAmelCase						):
    a__     : Tuple  =f'''{id_pred["idx"]["paragraph"]}-{id_pred["idx"]["question"]}'''
    a__     : Union[str, Any]  =id_pred["prediction"]
    if question_id in question_map:
      question_map[question_id].append((pred, label)						)
    else:
      a__     : Union[str, Any]  =[(pred, label)]
  a__     : Optional[int]  =[], []
  for question, preds_labels in question_map.items():
    a__     : Dict  =zip(*_UpperCAmelCase						)
    a__     : Any  =fa_score(y_true=_UpperCAmelCase	,	y_pred=_UpperCAmelCase	,	average="macro"						)
    fas.append(_UpperCAmelCase						)
    a__     : Any  =int(sum(pred == label for pred, label in preds_labels						) == len(_UpperCAmelCase						)						)
    ems.append(_UpperCAmelCase						)
  a__     : Any  =float(sum(_UpperCAmelCase						) / len(_UpperCAmelCase						)						)
  a__     : Optional[int]  =sum(_UpperCAmelCase						) / len(_UpperCAmelCase						)
  a__     : Union[str, Any]  =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):







      def        _lowercase  (   self							)       ->						str:



        '''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        _lowercase  (   self							)       ->						Optional[Any]:



        '''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        _lowercase  (   self		,				lowerCAmelCase__		,				lowerCAmelCase__							)       ->						int:



        '''simple docstring'''




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











import inspect
import unittest

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

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


if is_torch_available():
     import torch

     from transformers import MobileNetVaForImageClassification, MobileNetVaModel
     from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import MobileNetVaImageProcessor







class     __lowerCAmelCase	(   UpperCamelCase__):







      def        _lowercase  (   self							)       ->						Any:



        '''simple docstring'''




        a__     : Optional[int]  =self.config_class(**self.inputs_dict							)
        self.parent.assertTrue(hasattr(lowerCAmelCase__		,				"tf_padding"							)							)
        self.parent.assertTrue(hasattr(lowerCAmelCase__		,				"depth_multiplier"							)							)







class     __lowerCAmelCase	:







      def __init__(   self		,				lowerCAmelCase__		,				lowerCAmelCase__=1_3		,				lowerCAmelCase__=3		,				lowerCAmelCase__=3_2		,				lowerCAmelCase__=0.25		,				lowerCAmelCase__=8		,				lowerCAmelCase__=True		,				lowerCAmelCase__=1_0_2_4		,				lowerCAmelCase__=3_2		,				lowerCAmelCase__="relu6"		,				lowerCAmelCase__=0.1		,				lowerCAmelCase__=0.02		,				lowerCAmelCase__=True		,				lowerCAmelCase__=True		,				lowerCAmelCase__=1_0		,				lowerCAmelCase__=None		,				)       ->						Dict:



        '''simple docstring'''




        a__     : int  =parent
        a__     : Optional[Any]  =batch_size
        a__     : Tuple  =num_channels
        a__     : Dict  =image_size
        a__     : Union[str, Any]  =depth_multiplier
        a__     : List[str]  =min_depth
        a__     : Dict  =tf_padding
        a__     : Any  =int(last_hidden_size * depth_multiplier							)
        a__     : Tuple  =output_stride
        a__     : Optional[Any]  =hidden_act
        a__     : str  =classifier_dropout_prob
        a__     : int  =use_labels
        a__     : List[Any]  =is_training
        a__     : List[str]  =num_labels
        a__     : Dict  =initializer_range
        a__     : Tuple  =scope







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



        '''simple docstring'''




        a__     : Union[str, Any]  =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

        a__     : Any  =None
        a__     : List[Any]  =None
        if self.use_labels:
          a__     : Dict  =ids_tensor([self.batch_size]		,				self.num_labels							)
          a__     : Tuple  =ids_tensor([self.batch_size, self.image_size, self.image_size]		,				self.num_labels							)

        a__     : Optional[Any]  =self.get_config()

        return config, pixel_values, labels, pixel_labels







      def        _lowercase  (   self							)       ->						str:



        '''simple docstring'''




        return MobileNetVaConfig(
            num_channels=self.num_channels		,				image_size=self.image_size		,				depth_multiplier=self.depth_multiplier		,				min_depth=self.min_depth		,				tf_padding=self.tf_padding		,				hidden_act=self.hidden_act		,				classifier_dropout_prob=self.classifier_dropout_prob		,				initializer_range=self.initializer_range		,				)







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



        '''simple docstring'''




        a__     : Union[str, Any]  =MobileNetVaModel(config=lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__     : str  =model(lowerCAmelCase__							)
        self.parent.assertEqual(
            result.last_hidden_state.shape		,				(
                self.batch_size,
                self.last_hidden_size,
                self.image_size // self.output_stride,
                self.image_size // self.output_stride,
            )		,				)







      def        _lowercase  (   self		,				lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__							)       ->						str:



        '''simple docstring'''




        a__     : Any  =self.num_labels
        a__     : Dict  =MobileNetVaForImageClassification(lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__     : Optional[int]  =model(lowerCAmelCase__		,				labels=lowerCAmelCase__							)
        self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_labels)							)







      def        _lowercase  (   self							)       ->						str:



        '''simple docstring'''




        a__     : str  =self.prepare_config_and_inputs()
        a__ ,							a__ ,							a__ ,							a__     : List[str]  =config_and_inputs
        a__     : Tuple  ={"pixel_values": pixel_values}
        return config, inputs_dict







@require_torch
class     __lowerCAmelCase	(   UpperCamelCase__						,    UpperCamelCase__						,    unittest.TestCase):
      _lowercase    : List[str]            =      (MobileNetVaModel, MobileNetVaForImageClassification) if is_torch_available() else ()
      _lowercase    : Optional[int]            =      (
          {"""feature-extraction""": MobileNetVaModel, """image-classification""": MobileNetVaForImageClassification}
          if is_torch_available()
          else {}
      )

      _lowercase    : Union[str, Any]            =      False
      _lowercase    : Optional[int]            =      False
      _lowercase    : List[str]            =      False
      _lowercase    : str            =      False







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



        '''simple docstring'''




        a__     : Optional[Any]  =MobileNetVaModelTester(self							)
        a__     : Optional[Any]  =MobileNetVaConfigTester(self		,				config_class=lowerCAmelCase__		,				has_text_modality=lowerCAmelCase__							)







      def        _lowercase  (   self							)       ->						Dict:



        '''simple docstring'''




        self.config_tester.run_common_tests()







      @unittest.skip(reason="MobileNetV1 does not use inputs_embeds"							)
      def        _lowercase  (   self							)       ->						Union[str, Any]:



        '''simple docstring'''




        pass







      @unittest.skip(reason="MobileNetV1 does not support input and output embeddings"							)
      def        _lowercase  (   self							)       ->						List[str]:



        '''simple docstring'''




        pass







      @unittest.skip(reason="MobileNetV1 does not output attentions"							)
      def        _lowercase  (   self							)       ->						Any:



        '''simple docstring'''




        pass







      def        _lowercase  (   self							)       ->						str:



        '''simple docstring'''




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

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

          a__     : Union[str, Any]  =["pixel_values"]
          self.assertListEqual(arg_names[:1]		,				lowerCAmelCase__							)







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



        '''simple docstring'''




        a__     : Optional[Any]  =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCAmelCase__							)







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



        '''simple docstring'''




        def check_hidden_states_output(lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__							):
          a__     : int  =model_class(lowerCAmelCase__							)
          model.to(lowerCAmelCase__							)
          model.eval()

          with torch.no_grad():
            a__     : List[Any]  =model(**self._prepare_for_class(lowerCAmelCase__		,				lowerCAmelCase__							)							)

          a__     : Optional[int]  =outputs.hidden_states

          a__     : Optional[int]  =2_6
          self.assertEqual(len(lowerCAmelCase__							)		,				lowerCAmelCase__							)

        a__ ,							a__     : Optional[Any]  =self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          a__     : Optional[int]  =True
          check_hidden_states_output(lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__							)

          # check that output_hidden_states also work using config
          del inputs_dict["output_hidden_states"]
          a__     : Union[str, Any]  =True

          check_hidden_states_output(lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__							)







      def        _lowercase  (   self							)       ->						Any:



        '''simple docstring'''




        a__     : Dict  =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__							)







      @slow
      def        _lowercase  (   self							)       ->						Any:



        '''simple docstring'''




        for model_name in MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          a__     : List[str]  =MobileNetVaModel.from_pretrained(lowerCAmelCase__							)
          self.assertIsNotNone(lowerCAmelCase__							)
def 					_A	(		):





  """simple docstring"""



  a__     : Optional[Any]  =Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
  return image







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







      @cached_property
      def        _lowercase  (   self							)       ->						Optional[Any]:



        '''simple docstring'''




        return (
            MobileNetVaImageProcessor.from_pretrained("google/mobilenet_v1_1.0_224"							) if is_vision_available() else None
        )







      @slow
      def        _lowercase  (   self							)       ->						Optional[int]:



        '''simple docstring'''




        a__     : str  =MobileNetVaForImageClassification.from_pretrained("google/mobilenet_v1_1.0_224"							).to(lowerCAmelCase__							)

        a__     : Optional[Any]  =self.default_image_processor
        a__     : Optional[int]  =prepare_img()
        a__     : Optional[int]  =image_processor(images=lowerCAmelCase__		,				return_tensors="pt"							).to(lowerCAmelCase__							)

        # forward pass
        with torch.no_grad():
          a__     : int  =model(**lowerCAmelCase__							)

        # verify the logits
        a__     : str  =torch.Size((1, 1_0_0_1)							)
        self.assertEqual(outputs.logits.shape		,				lowerCAmelCase__							)

        a__     : int  =torch.tensor([-4.17_39, -1.12_33, 3.12_05]							).to(lowerCAmelCase__							)

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






