



"""simple docstring"""





import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCAmelCase       :					str      					=					logging.get_logger(__name__)

__lowerCAmelCase       :					Optional[int]      					=					{
    '''b0''': efficientnet.EfficientNetBa,
    '''b1''': efficientnet.EfficientNetBa,
    '''b2''': efficientnet.EfficientNetBa,
    '''b3''': efficientnet.EfficientNetBa,
    '''b4''': efficientnet.EfficientNetBa,
    '''b5''': efficientnet.EfficientNetBa,
    '''b6''': efficientnet.EfficientNetBa,
    '''b7''': efficientnet.EfficientNetBa,
}

__lowerCAmelCase       :					Dict      					=					{
    '''b0''': {
        '''hidden_dim''': 1280,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.0,
        '''image_size''': 224,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [],
    },
    '''b1''': {
        '''hidden_dim''': 1280,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.1,
        '''image_size''': 240,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [16],
    },
    '''b2''': {
        '''hidden_dim''': 1408,
        '''width_coef''': 1.1,
        '''depth_coef''': 1.2,
        '''image_size''': 260,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 8, 16],
    },
    '''b3''': {
        '''hidden_dim''': 1536,
        '''width_coef''': 1.2,
        '''depth_coef''': 1.4,
        '''image_size''': 300,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 18],
    },
    '''b4''': {
        '''hidden_dim''': 1792,
        '''width_coef''': 1.4,
        '''depth_coef''': 1.8,
        '''image_size''': 380,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [6],
    },
    '''b5''': {
        '''hidden_dim''': 2048,
        '''width_coef''': 1.6,
        '''depth_coef''': 2.2,
        '''image_size''': 456,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [13, 27],
    },
    '''b6''': {
        '''hidden_dim''': 2304,
        '''width_coef''': 1.8,
        '''depth_coef''': 2.6,
        '''image_size''': 528,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [31],
    },
    '''b7''': {
        '''hidden_dim''': 2560,
        '''width_coef''': 2.0,
        '''depth_coef''': 3.1,
        '''image_size''': 600,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [18],
    },
}
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Any    ):


						'''simple docstring'''






						snake_case_   : Optional[Any]						=			EfficientNetConfig()
						snake_case_   : Dict						=			CONFIG_MAP[model_name]["""hidden_dim"""]
						snake_case_   : Optional[Any]						=			CONFIG_MAP[model_name]["""width_coef"""]
						snake_case_   : Tuple						=			CONFIG_MAP[model_name]["""depth_coef"""]
						snake_case_   : Any						=			CONFIG_MAP[model_name]["""image_size"""]
						snake_case_   : Optional[int]						=			CONFIG_MAP[model_name]["""dropout_rate"""]
						snake_case_   : int						=			CONFIG_MAP[model_name]["""dw_padding"""]

						snake_case_   : Optional[Any]						=			"""huggingface/label-files"""
						snake_case_   : Tuple						=			"""imagenet-1k-id2label.json"""
						snake_case_   : str						=			1_0_0_0
						snake_case_   : Any						=			json.load(open(hf_hub_download(__UpperCamelCase					, __UpperCamelCase					, repo_type="""dataset"""    )					, """r"""    )    )
						snake_case_   : List[str]						=			{int(__UpperCamelCase    ): v for k, v in idalabel.items()}

						snake_case_   : List[Any]						=			idalabel
						snake_case_   : Tuple						=			{v: k for k, v in idalabel.items()}
						return config
def 	__lowerCAmelCase						(		):


						'''simple docstring'''






						snake_case_   : Any						=			"""http://images.cocodataset.org/val2017/000000039769.jpg"""
						snake_case_   : str						=			Image.open(requests.get(__UpperCamelCase					, stream=__UpperCamelCase    ).raw    )
						return im
def 	__lowerCAmelCase						(		__UpperCamelCase      :			str    ):


						'''simple docstring'''






						snake_case_   : List[str]						=			CONFIG_MAP[model_name]["""image_size"""]
						snake_case_   : Optional[Any]						=			EfficientNetImageProcessor(
						    size={"""height""": size, """width""": size}					, image_mean=[0.485, 0.456, 0.406]					, image_std=[0.47_853_944, 0.4_732_864, 0.47_434_163]					, do_center_crop=__UpperCamelCase					, )
						return preprocessor
def 	__lowerCAmelCase						(		__UpperCamelCase      :			int    ):


						'''simple docstring'''






						snake_case_   : List[str]						=			[v.split("""_"""    )[0].split("""block"""    )[1] for v in original_param_names if v.startswith("""block"""    )]
						snake_case_   : Union[str, Any]						=			sorted(set(__UpperCamelCase    )    )
						snake_case_   : Optional[Any]						=			len(__UpperCamelCase    )
						snake_case_   : int						=			{b: str(__UpperCamelCase    ) for b, i in zip(__UpperCamelCase					, range(__UpperCamelCase    )    )}

						snake_case_   : Optional[int]						=			[]
						rename_keys.append(("""stem_conv/kernel:0""", """embeddings.convolution.weight""")    )
						rename_keys.append(("""stem_bn/gamma:0""", """embeddings.batchnorm.weight""")    )
						rename_keys.append(("""stem_bn/beta:0""", """embeddings.batchnorm.bias""")    )
						rename_keys.append(("""stem_bn/moving_mean:0""", """embeddings.batchnorm.running_mean""")    )
						rename_keys.append(("""stem_bn/moving_variance:0""", """embeddings.batchnorm.running_var""")    )

						for b in block_names:
												snake_case_   : str						=			block_name_mapping[b]
												rename_keys.append((F'block{b}_expand_conv/kernel:0', F'encoder.blocks.{hf_b}.expansion.expand_conv.weight')    )
												rename_keys.append((F'block{b}_expand_bn/gamma:0', F'encoder.blocks.{hf_b}.expansion.expand_bn.weight')    )
												rename_keys.append((F'block{b}_expand_bn/beta:0', F'encoder.blocks.{hf_b}.expansion.expand_bn.bias')    )
												rename_keys.append(
												    (F'block{b}_expand_bn/moving_mean:0', F'encoder.blocks.{hf_b}.expansion.expand_bn.running_mean')    )
												rename_keys.append(
												    (F'block{b}_expand_bn/moving_variance:0', F'encoder.blocks.{hf_b}.expansion.expand_bn.running_var')    )
												rename_keys.append(
												    (F'block{b}_dwconv/depthwise_kernel:0', F'encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight')    )
												rename_keys.append((F'block{b}_bn/gamma:0', F'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight')    )
												rename_keys.append((F'block{b}_bn/beta:0', F'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias')    )
												rename_keys.append(
												    (F'block{b}_bn/moving_mean:0', F'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean')    )
												rename_keys.append(
												    (F'block{b}_bn/moving_variance:0', F'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var')    )

												rename_keys.append((F'block{b}_se_reduce/kernel:0', F'encoder.blocks.{hf_b}.squeeze_excite.reduce.weight')    )
												rename_keys.append((F'block{b}_se_reduce/bias:0', F'encoder.blocks.{hf_b}.squeeze_excite.reduce.bias')    )
												rename_keys.append((F'block{b}_se_expand/kernel:0', F'encoder.blocks.{hf_b}.squeeze_excite.expand.weight')    )
												rename_keys.append((F'block{b}_se_expand/bias:0', F'encoder.blocks.{hf_b}.squeeze_excite.expand.bias')    )
												rename_keys.append(
												    (F'block{b}_project_conv/kernel:0', F'encoder.blocks.{hf_b}.projection.project_conv.weight')    )
												rename_keys.append((F'block{b}_project_bn/gamma:0', F'encoder.blocks.{hf_b}.projection.project_bn.weight')    )
												rename_keys.append((F'block{b}_project_bn/beta:0', F'encoder.blocks.{hf_b}.projection.project_bn.bias')    )
												rename_keys.append(
												    (F'block{b}_project_bn/moving_mean:0', F'encoder.blocks.{hf_b}.projection.project_bn.running_mean')    )
												rename_keys.append(
												    (F'block{b}_project_bn/moving_variance:0', F'encoder.blocks.{hf_b}.projection.project_bn.running_var')    )

						rename_keys.append(("""top_conv/kernel:0""", """encoder.top_conv.weight""")    )
						rename_keys.append(("""top_bn/gamma:0""", """encoder.top_bn.weight""")    )
						rename_keys.append(("""top_bn/beta:0""", """encoder.top_bn.bias""")    )
						rename_keys.append(("""top_bn/moving_mean:0""", """encoder.top_bn.running_mean""")    )
						rename_keys.append(("""top_bn/moving_variance:0""", """encoder.top_bn.running_var""")    )

						snake_case_   : List[Any]						=			{}
						for item in rename_keys:
												if item[0] in original_param_names:
																		snake_case_   : str						=			"""efficientnet.""" + item[1]

						snake_case_   : str						=			"""classifier.weight"""
						snake_case_   : List[Any]						=			"""classifier.bias"""
						return key_mapping
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Optional[int]					, __UpperCamelCase      :			Any					, __UpperCamelCase      :			Dict    ):


						'''simple docstring'''






						for key, value in tf_params.items():
												if "normalization" in key:
																		continue

												snake_case_   : Union[str, Any]						=			key_mapping[key]
												if "_conv" in key and "kernel" in key:
																		snake_case_   : Dict						=			torch.from_numpy(__UpperCamelCase    ).permute(3					, 2					, 0					, 1    )
												elif "depthwise_kernel" in key:
																		snake_case_   : Optional[int]						=			torch.from_numpy(__UpperCamelCase    ).permute(2					, 3					, 0					, 1    )
												elif "kernel" in key:
																		snake_case_   : int						=			torch.from_numpy(np.transpose(__UpperCamelCase    )    )
												else:
																		snake_case_   : str						=			torch.from_numpy(__UpperCamelCase    )

												# Replace HF parameters with original TF model parameters
												assert hf_params[hf_key].shape == new_hf_value.shape
												hf_params[hf_key].copy_(__UpperCamelCase    )
@torch.no_grad()
def 	__lowerCAmelCase						(		__UpperCamelCase      :			List[Any]					, __UpperCamelCase      :			Dict					, __UpperCamelCase      :			int					, __UpperCamelCase      :			Any    ):


						'''simple docstring'''






						snake_case_   : List[Any]						=			model_classes[model_name](
						    include_top=__UpperCamelCase					, weights="""imagenet"""					, input_tensor=__UpperCamelCase					, input_shape=__UpperCamelCase					, pooling=__UpperCamelCase					, classes=1_0_0_0					, classifier_activation="""softmax"""					, )

						snake_case_   : str						=			original_model.trainable_variables
						snake_case_   : Union[str, Any]						=			original_model.non_trainable_variables
						snake_case_   : Any						=			{param.name: param.numpy() for param in tf_params}
						for param in tf_non_train_params:
												snake_case_   : Dict						=			param.numpy()
						snake_case_   : Dict						=			list(tf_params.keys()    )

						# Load HuggingFace model
						snake_case_   : List[Any]						=			get_efficientnet_config(__UpperCamelCase    )
						snake_case_   : int						=			EfficientNetForImageClassification(__UpperCamelCase    ).eval()
						snake_case_   : Any						=			hf_model.state_dict()

						# Create src-to-dst parameter name mapping dictionary
						print("""Converting parameters..."""    )
						snake_case_   : Optional[int]						=			rename_keys(__UpperCamelCase    )
						replace_params(__UpperCamelCase					, __UpperCamelCase					, __UpperCamelCase    )

						# Initialize preprocessor and preprocess input image
						snake_case_   : Optional[int]						=			convert_image_processor(__UpperCamelCase    )
						snake_case_   : Any						=			preprocessor(images=prepare_img()					, return_tensors="""pt"""    )

						# HF model inference
						hf_model.eval()
						with torch.no_grad():
												snake_case_   : int						=			hf_model(**__UpperCamelCase    )
						snake_case_   : int						=			outputs.logits.detach().numpy()

						# Original model inference
						snake_case_   : Union[str, Any]						=			False
						snake_case_   : Optional[int]						=			CONFIG_MAP[model_name]["""image_size"""]
						snake_case_   : List[Any]						=			prepare_img().resize((image_size, image_size)					, resample=PIL.Image.NEAREST    )
						snake_case_   : str						=			image.img_to_array(__UpperCamelCase    )
						snake_case_   : Union[str, Any]						=			np.expand_dims(__UpperCamelCase					, axis=0    )
						snake_case_   : List[Any]						=			original_model.predict(__UpperCamelCase    )

						# Check whether original and HF model outputs match  -> np.allclose
						assert np.allclose(__UpperCamelCase					, __UpperCamelCase					, atol=1E-3    ), "The predicted logits are not the same."
						print("""Model outputs match!"""    )

						if save_model:
												# Create folder to save model
												if not os.path.isdir(__UpperCamelCase    ):
																		os.mkdir(__UpperCamelCase    )
												# Save converted model and image processor
												hf_model.save_pretrained(__UpperCamelCase    )
												preprocessor.save_pretrained(__UpperCamelCase    )

						if push_to_hub:
												# Push model and image processor to hub
												print(F'Pushing converted {model_name} to the hub...'    )
												snake_case_   : Any						=			F'efficientnet-{model_name}'
												preprocessor.push_to_hub(__UpperCamelCase    )
												hf_model.push_to_hub(__UpperCamelCase    )


if __name__ == "__main__":
					__lowerCAmelCase       :					str      					=					argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '''--model_name''',
					    default='''b0''',
					    type=str,
					    help='''Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].''',
					)
					parser.add_argument(
					    '''--pytorch_dump_folder_path''',
					    default='''hf_model''',
					    type=str,
					    help='''Path to the output PyTorch model directory.''',
					)
					parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
					parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''')

					__lowerCAmelCase       :					Optional[int]      					=					parser.parse_args()
					convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)








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

