






import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin







class  _lowercase   (   _A						):
      # to overwrite at feature extractactor specific tests
      _a							:						List[str]										=							None
      _a							:						int										=							None
      @property
      def 						lowercase__					(     self   ):
       return self.feat_extract_tester.prepare_feat_extract_dict()
      def 						lowercase__					(     self   ):
       snake_case__  :    str							       =self.feature_extraction_class(**self.feat_extract_dict   )
       self.assertTrue(hasattr(a				,			"""feature_size"""   )   )
       self.assertTrue(hasattr(a				,			"""sampling_rate"""   )   )
       self.assertTrue(hasattr(a				,			"""padding_value"""   )   )
      def 						lowercase__					(     self   ):
       snake_case__  :    List[Any]							       =self.feat_extract_tester.prepare_inputs_for_common()
       snake_case__  :    List[str]							       =self.feature_extraction_class(**self.feat_extract_dict   )
       snake_case__  :    Dict							       =feat_extract.model_input_names[0]

       snake_case__  :    Union[str, Any]							       =BatchFeature({input_name: speech_inputs}   )

       self.assertTrue(all(len(a   ) == len(a   ) for x, y in zip(a				,			processed_features[input_name]   )   )   )

       snake_case__  :    Any							       =self.feat_extract_tester.prepare_inputs_for_common(equal_length=a   )
       snake_case__  :    List[Any]							       =BatchFeature({input_name: speech_inputs}				,			tensor_type="""np"""   )

       snake_case__  :    List[Any]							       =processed_features[input_name]

       if len(batch_features_input.shape   ) < 3:
        snake_case__  :    str							       =batch_features_input[:, :, None]

       self.assertTrue(
           batch_features_input.shape
           == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )
      @require_torch
      def 						lowercase__					(     self   ):
       snake_case__  :    Union[str, Any]							       =self.feat_extract_tester.prepare_inputs_for_common(equal_length=a   )
       snake_case__  :    Dict							       =self.feature_extraction_class(**self.feat_extract_dict   )
       snake_case__  :    str							       =feat_extract.model_input_names[0]

       snake_case__  :    Union[str, Any]							       =BatchFeature({input_name: speech_inputs}				,			tensor_type="""pt"""   )

       snake_case__  :    Union[str, Any]							       =processed_features[input_name]

       if len(batch_features_input.shape   ) < 3:
        snake_case__  :    List[str]							       =batch_features_input[:, :, None]

       self.assertTrue(
           batch_features_input.shape
           == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )
      @require_tf
      def 						lowercase__					(     self   ):
       snake_case__  :    str							       =self.feat_extract_tester.prepare_inputs_for_common(equal_length=a   )
       snake_case__  :    int							       =self.feature_extraction_class(**self.feat_extract_dict   )
       snake_case__  :    Tuple							       =feat_extract.model_input_names[0]

       snake_case__  :    int							       =BatchFeature({input_name: speech_inputs}				,			tensor_type="""tf"""   )

       snake_case__  :    Any							       =processed_features[input_name]

       if len(batch_features_input.shape   ) < 3:
        snake_case__  :    Optional[int]							       =batch_features_input[:, :, None]

       self.assertTrue(
           batch_features_input.shape
           == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )
      def 						lowercase__					(     self				,			a=False   ):
       def _inputs_have_equal_length(a   ):
        snake_case__  :    List[Any]							       =len(input[0]   )
        for input_slice in input[1:]:
         if len(a   ) != length:
          return False
        return True

       def _inputs_are_equal(a				,			a   ):
        if len(a   ) != len(a   ):
         return False

        for input_slice_a, input_slice_a in zip(a				,			a   ):
         if not np.allclose(np.asarray(a   )				,			np.asarray(a   )				,			atol=1e-3   ):
          return False
        return True

       snake_case__  :    Tuple							       =self.feature_extraction_class(**self.feat_extract_dict   )
       snake_case__  :    List[str]							       =self.feat_extract_tester.prepare_inputs_for_common(numpify=a   )
       snake_case__  :    Any							       =feat_extract.model_input_names[0]

       snake_case__  :    Tuple							       =BatchFeature({input_name: speech_inputs}   )

       snake_case__  :    Any							       =self.feat_extract_tester.seq_length_diff
       snake_case__  :    List[str]							       =self.feat_extract_tester.max_seq_length + pad_diff
       snake_case__  :    Any							       =self.feat_extract_tester.min_seq_length
       snake_case__  :    Union[str, Any]							       =self.feat_extract_tester.batch_size
       snake_case__  :    List[str]							       =self.feat_extract_tester.feature_size

       # test padding for List[int] + numpy
       snake_case__  :    List[str]							       =feat_extract.pad(a				,			padding=a   )
       snake_case__  :    Optional[Any]							       =input_a[input_name]

       snake_case__  :    Optional[int]							       =feat_extract.pad(a				,			padding="""longest"""   )
       snake_case__  :    Tuple							       =input_a[input_name]

       snake_case__  :    Any							       =feat_extract.pad(a				,			padding="""max_length"""				,			max_length=len(speech_inputs[-1]   )   )
       snake_case__  :    int							       =input_a[input_name]

       snake_case__  :    Tuple							       =feat_extract.pad(a				,			padding="""longest"""				,			return_tensors="""np"""   )
       snake_case__  :    int							       =input_a[input_name]

       # max_length parameter has to be provided when setting `padding="max_length"`
       with self.assertRaises(a   ):
        feat_extract.pad(a				,			padding="""max_length"""   )[input_name]

       snake_case__  :    Dict							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			max_length=a				,			return_tensors="""np"""   )
       snake_case__  :    Any							       =input_a[input_name]

       self.assertFalse(_inputs_have_equal_length(a   )   )
       self.assertTrue(_inputs_have_equal_length(a   )   )
       self.assertTrue(_inputs_have_equal_length(a   )   )
       self.assertTrue(_inputs_are_equal(a				,			a   )   )
       self.assertTrue(len(input_a[0]   ) == pad_min_length   )
       self.assertTrue(len(input_a[1]   ) == pad_min_length + pad_diff   )
       self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]   ))   )
       self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)   )

       if feature_size > 1:
        self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size   )

       # test padding for `pad_to_multiple_of` for List[int] + numpy
       snake_case__  :    Tuple							       =feat_extract.pad(a				,			pad_to_multiple_of=1_0   )
       snake_case__  :    Union[str, Any]							       =input_a[input_name]

       snake_case__  :    Optional[Any]							       =feat_extract.pad(a				,			padding="""longest"""				,			pad_to_multiple_of=1_0   )
       snake_case__  :    List[Any]							       =input_a[input_name]

       snake_case__  :    int							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			pad_to_multiple_of=1_0				,			max_length=a   )
       snake_case__  :    int							       =input_a[input_name]

       snake_case__  :    Dict							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			pad_to_multiple_of=1_0				,			max_length=a				,			return_tensors="""np"""				,			)
       snake_case__  :    List[str]							       =input_a[input_name]

       self.assertTrue(all(len(a   ) % 1_0 == 0 for x in input_a   )   )
       self.assertTrue(_inputs_are_equal(a				,			a   )   )

       snake_case__  :    Tuple							       =pad_max_length if pad_max_length % 1_0 == 0 else (pad_max_length // 1_0 + 1) * 1_0
       self.assertTrue(all(len(a   ) == expected_mult_pad_length for x in input_a   )   )
       self.assertEqual(input_a.shape[:2]				,			(batch_size, expected_mult_pad_length)   )

       if feature_size > 1:
        self.assertTrue(input_a.shape[2] == feature_size   )

       # Check padding value is correct
       snake_case__  :    str							       =(np.ones(self.feat_extract_tester.feature_size   ) * feat_extract.padding_value).sum()
       self.assertTrue(
           abs(np.asarray(input_a[0]   )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)   )
           < 1e-3   )
       self.assertTrue(
           abs(
               np.asarray(input_a[1]   )[pad_min_length + pad_diff :].sum()
               - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)   )
           < 1e-3   )
       self.assertTrue(
           abs(
               np.asarray(input_a[2]   )[pad_min_length + 2 * pad_diff :].sum()
               - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)   )
           < 1e-3   )
       self.assertTrue(
           abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)   ) < 1e-3   )
       self.assertTrue(
           abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)   )
           < 1e-3   )
      def 						lowercase__					(     self				,			a=False   ):
       def _inputs_have_equal_length(a   ):
        snake_case__  :    Any							       =len(input[0]   )
        for input_slice in input[1:]:
         if len(a   ) != length:
          return False
        return True

       def _inputs_are_equal(a				,			a   ):
        if len(a   ) != len(a   ):
         return False

        for input_slice_a, input_slice_a in zip(a				,			a   ):
         if not np.allclose(np.asarray(a   )				,			np.asarray(a   )				,			atol=1e-3   ):
          return False
        return True

       snake_case__  :    str							       =self.feature_extraction_class(**self.feat_extract_dict   )
       snake_case__  :    Optional[int]							       =self.feat_extract_tester.prepare_inputs_for_common(numpify=a   )
       snake_case__  :    Tuple							       =feat_extract.model_input_names[0]

       snake_case__  :    Any							       =BatchFeature({input_name: speech_inputs}   )

       # truncate to smallest
       snake_case__  :    List[Any]							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			max_length=len(speech_inputs[0]   )				,			truncation=a   )
       snake_case__  :    Union[str, Any]							       =input_a[input_name]

       snake_case__  :    str							       =feat_extract.pad(a				,			padding="""max_length"""				,			max_length=len(speech_inputs[0]   )   )
       snake_case__  :    Optional[int]							       =input_a[input_name]

       self.assertTrue(_inputs_have_equal_length(a   )   )
       self.assertFalse(_inputs_have_equal_length(a   )   )

       # truncate to smallest with np
       snake_case__  :    Any							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			max_length=len(speech_inputs[0]   )				,			return_tensors="""np"""				,			truncation=a				,			)
       snake_case__  :    Optional[Any]							       =input_a[input_name]

       snake_case__  :    Optional[int]							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			max_length=len(speech_inputs[0]   )				,			return_tensors="""np"""   )
       snake_case__  :    Dict							       =input_a[input_name]

       self.assertTrue(_inputs_have_equal_length(a   )   )
       self.assertTrue(input_a.shape[1] == len(speech_inputs[0]   )   )

       # since truncation forces padding to be smaller than longest input
       # function can't return `np.ndarray`, but has to return list
       self.assertFalse(_inputs_have_equal_length(a   )   )

       # truncate to middle
       snake_case__  :    Tuple							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			max_length=len(speech_inputs[1]   )				,			truncation=a				,			return_tensors="""np"""				,			)
       snake_case__  :    Optional[int]							       =input_a[input_name]

       snake_case__  :    List[str]							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			max_length=len(speech_inputs[1]   )				,			truncation=a   )
       snake_case__  :    Optional[Any]							       =input_a[input_name]

       snake_case__  :    List[Any]							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			max_length=len(speech_inputs[1]   )				,			return_tensors="""np"""   )
       snake_case__  :    List[Any]							       =input_a[input_name]

       self.assertTrue(input_a.shape[1] == len(speech_inputs[1]   )   )
       self.assertTrue(_inputs_have_equal_length(a   )   )
       self.assertTrue(_inputs_have_equal_length(a   )   )
       self.assertTrue(_inputs_are_equal(a				,			a   )   )

       # since truncation forces padding to be smaller than longest input
       # function can't return `np.ndarray`, but has to return list
       self.assertFalse(_inputs_have_equal_length(a   )   )
       self.assertTrue(len(input_a[-1]   ) == len(speech_inputs[-1]   )   )

       # padding has to be max_length when setting `truncation=True`
       with self.assertRaises(a   ):
        feat_extract.pad(a				,			truncation=a   )[input_name]

       # padding has to be max_length when setting `truncation=True`
       with self.assertRaises(a   ):
        feat_extract.pad(a				,			padding="""longest"""				,			truncation=a   )[input_name]

       # padding has to be max_length when setting `truncation=True`
       with self.assertRaises(a   ):
        feat_extract.pad(a				,			padding="""longest"""				,			truncation=a   )[input_name]

       # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
       with self.assertRaises(a   ):
        feat_extract.pad(a				,			padding="""max_length"""				,			truncation=a   )[input_name]

       # test truncation for `pad_to_multiple_of` for List[int] + numpy
       snake_case__  :    str							       =1_2
       snake_case__  :    Dict							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			max_length=len(speech_inputs[0]   )				,			pad_to_multiple_of=a				,			truncation=a				,			)
       snake_case__  :    Tuple							       =input_a[input_name]

       snake_case__  :    Union[str, Any]							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			max_length=len(speech_inputs[0]   )				,			pad_to_multiple_of=a				,			)
       snake_case__  :    int							       =input_a[input_name]

       # retrieve expected_length as multiple of pad_to_multiple_of
       snake_case__  :    Optional[Any]							       =len(speech_inputs[0]   )
       if expected_length % pad_to_multiple_of != 0:
        snake_case__  :    Dict							       =((len(speech_inputs[0]   ) // pad_to_multiple_of) + 1) * pad_to_multiple_of

       self.assertTrue(len(input_a[0]   ) == expected_length   )
       self.assertTrue(_inputs_have_equal_length(a   )   )
       self.assertFalse(_inputs_have_equal_length(a   )   )
      def 						lowercase__					(     self   ):
       self._check_padding(numpify=a   )
      def 						lowercase__					(     self   ):
       self._check_padding(numpify=a   )
      def 						lowercase__					(     self   ):
       self._check_truncation(numpify=a   )
      def 						lowercase__					(     self   ):
       self._check_truncation(numpify=a   )
      @require_torch
      def 						lowercase__					(     self   ):
       snake_case__  :    Union[str, Any]							       =self.feature_extraction_class(**self.feat_extract_dict   )
       snake_case__  :    Optional[Any]							       =self.feat_extract_tester.prepare_inputs_for_common()
       snake_case__  :    List[Any]							       =feat_extract.model_input_names[0]

       snake_case__  :    str							       =BatchFeature({input_name: speech_inputs}   )

       snake_case__  :    Optional[Any]							       =feat_extract.pad(a				,			padding="""longest"""				,			return_tensors="""np"""   )[input_name]
       snake_case__  :    Optional[Any]							       =feat_extract.pad(a				,			padding="""longest"""				,			return_tensors="""pt"""   )[input_name]

       self.assertTrue(abs(input_np.astype(np.floataa   ).sum() - input_pt.numpy().astype(np.floataa   ).sum()   ) < 1e-2   )
      @require_tf
      def 						lowercase__					(     self   ):
       snake_case__  :    List[str]							       =self.feature_extraction_class(**self.feat_extract_dict   )
       snake_case__  :    Dict							       =self.feat_extract_tester.prepare_inputs_for_common()
       snake_case__  :    Union[str, Any]							       =feat_extract.model_input_names[0]

       snake_case__  :    str							       =BatchFeature({input_name: speech_inputs}   )

       snake_case__  :    Optional[Any]							       =feat_extract.pad(a				,			padding="""longest"""				,			return_tensors="""np"""   )[input_name]
       snake_case__  :    Dict							       =feat_extract.pad(a				,			padding="""longest"""				,			return_tensors="""tf"""   )[input_name]

       self.assertTrue(abs(input_np.astype(np.floataa   ).sum() - input_tf.numpy().astype(np.floataa   ).sum()   ) < 1e-2   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =self.feat_extract_dict
       snake_case__  :    List[str]							       =True
       snake_case__  :    Any							       =self.feature_extraction_class(**a   )
       snake_case__  :    Dict							       =self.feat_extract_tester.prepare_inputs_for_common()
       snake_case__  :    Optional[int]							       =[len(a   ) for x in speech_inputs]
       snake_case__  :    Dict							       =feat_extract.model_input_names[0]

       snake_case__  :    List[str]							       =BatchFeature({input_name: speech_inputs}   )

       snake_case__  :    Optional[int]							       =feat_extract.pad(a				,			padding="""longest"""				,			return_tensors="""np"""   )
       self.assertIn("""attention_mask"""				,			a   )
       self.assertListEqual(list(processed.attention_mask.shape   )				,			list(processed[input_name].shape[:2]   )   )
       self.assertListEqual(processed.attention_mask.sum(-1   ).tolist()				,			a   )



      def 						lowercase__					(     self   ):
       snake_case__  :    Optional[Any]							       =self.feat_extract_dict
       snake_case__  :    Union[str, Any]							       =True
       snake_case__  :    Optional[Any]							       =self.feature_extraction_class(**a   )
       snake_case__  :    int							       =self.feat_extract_tester.prepare_inputs_for_common()
       snake_case__  :    List[Any]							       =[len(a   ) for x in speech_inputs]
       snake_case__  :    int							       =feat_extract.model_input_names[0]

       snake_case__  :    Any							       =BatchFeature({input_name: speech_inputs}   )
       snake_case__  :    Any							       =min(a   )

       snake_case__  :    Optional[Any]							       =feat_extract.pad(
           a				,			padding="""max_length"""				,			max_length=a				,			truncation=a				,			return_tensors="""np"""   )
       self.assertIn("""attention_mask"""				,			a   )
       self.assertListEqual(
           list(processed_pad.attention_mask.shape   )				,			[processed_pad[input_name].shape[0], max_length]   )
       self.assertListEqual(
           processed_pad.attention_mask[:, :max_length].sum(-1   ).tolist()				,			[max_length for x in speech_inputs]   )













from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


__lowerCamelCase	:		Any										=   """\
@inproceedings{wang2019glue,
  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},
  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},
  note={In the Proceedings of ICLR.},
  year={2019}
}
"""

__lowerCamelCase	:		str										=   """\
GLUE, the General Language Understanding Evaluation benchmark
(https://gluebenchmark.com/) is a collection of resources for training,
evaluating, and analyzing natural language understanding systems.
"""

__lowerCamelCase	:		str										=   """
Compute GLUE evaluation metric associated to each GLUE dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
Returns: depending on the GLUE subset, one or several of:
    \"accuracy\": Accuracy
    \"f1\": F1 score
    \"pearson\": Pearson Correlation
    \"spearmanr\": Spearman Correlation
    \"matthews_correlation\": Matthew Correlation
Examples:

    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0, 'f1': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'stsb')
    >>> references = [0., 1., 2., 3., 4., 5.]
    >>> predictions = [0., 1., 2., 3., 4., 5.]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})
    {'pearson': 1.0, 'spearmanr': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'cola')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'matthews_correlation': 1.0}
"""







def 			A__							(      _a  :					int		,  _a  :					str	):





 '''simple docstring'''







 return float((preds == labels).mean()	)







def 			A__							(      _a  :					Optional[Any]		,  _a  :					Any	):





 '''simple docstring'''







 snake_case__  :    str							       =simple_accuracy(_a		,  _a	)
 snake_case__  :    str							       =float(fa_score(y_true=_a		,  y_pred=_a	)	)
 return {
     "accuracy": acc,
     "f1": fa,
 }







def 			A__							(      _a  :					int		,  _a  :					Optional[int]	):





 '''simple docstring'''







 snake_case__  :    str							       =float(pearsonr(_a		,  _a	)[0]	)
 snake_case__  :    Optional[int]							       =float(spearmanr(_a		,  _a	)[0]	)
 return {
     "pearson": pearson_corr,
     "spearmanr": spearman_corr,
 }







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,				_KWARGS_DESCRIPTION						)
class  _lowercase   (   datasets.Metric						):
      def 						lowercase__					(     self   ):
       if self.config_name not in [
           "sst2",
           "mnli",
           "mnli_mismatched",
           "mnli_matched",
           "cola",
           "stsb",
           "mrpc",
           "qqp",
           "qnli",
           "rte",
           "wnli",
           "hans",
       ]:
        raise KeyError(
            """You should supply a configuration name selected in """
            """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """
            """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]"""   )
       return datasets.MetricInfo(
           description=_DESCRIPTION				,			citation=_CITATION				,			inputs_description=_KWARGS_DESCRIPTION				,			features=datasets.Features(
               {
                   """predictions""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32"""   ),
                   """references""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32"""   ),
               }   )				,			codebase_urls=[]				,			reference_urls=[]				,			format="""numpy"""				,			)



      def 						lowercase__					(     self				,			a				,			a   ):
       if self.config_name == "cola":
        return {"matthews_correlation": matthews_corrcoef(a				,			a   )}
       elif self.config_name == "stsb":
        return pearson_and_spearman(a				,			a   )
       elif self.config_name in ["mrpc", "qqp"]:
        return acc_and_fa(a				,			a   )
       elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
        return {"accuracy": simple_accuracy(a				,			a   )}
       else:
        raise KeyError(
            """You should supply a configuration name selected in """
            """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """
            """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]"""   )





