






"""simple docstring"""







from sklearn.metrics import matthews_corrcoef

import datasets


a			:    int				 =		"""
Compute the Matthews correlation coefficient (MCC)

The Matthews correlation coefficient is used in machine learning as a
measure of the quality of binary and multiclass classifications. It takes
into account true and false positives and negatives and is generally
regarded as a balanced measure which can be used even if the classes are of
very different sizes. The MCC is in essence a correlation coefficient value
between -1 and +1. A coefficient of +1 represents a perfect prediction, 0
an average random prediction and -1 an inverse prediction.  The statistic
is also known as the phi coefficient. [source: Wikipedia]
"""

a			:    List[str]				 =		"""
Args:
    predictions (list of int): Predicted labels, as returned by a model.
    references (list of int): Ground truth labels.
    sample_weight (list of int, float, or bool): Sample weights. Defaults to `None`.
Returns:
    matthews_correlation (dict containing float): Matthews correlation.
Examples:
    Example 1, a basic example with only predictions and references as inputs:
        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")
        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],
        ...                                     predictions=[1, 2, 2, 0, 3, 3])
        >>> print(round(results['matthews_correlation'], 2))
        0.54

    Example 2, the same example as above, but also including sample weights:
        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")
        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],
        ...                                     predictions=[1, 2, 2, 0, 3, 3],
        ...                                     sample_weight=[0.5, 3, 1, 1, 1, 2])
        >>> print(round(results['matthews_correlation'], 2))
        0.1

    Example 3, the same example as above, but with sample weights that cause a negative correlation:
        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")
        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],
        ...                                     predictions=[1, 2, 2, 0, 3, 3],
        ...                                     sample_weight=[0.5, 1, 0, 0, 0, 1])
        >>> print(round(results['matthews_correlation'], 2))
        -0.25
"""

a			:    Optional[int]				 =		"""\
@article{scikit-learn,
  title={Scikit-learn: Machine Learning in {P}ython},
  author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
  journal={Journal of Machine Learning Research},
  volume={12},
  pages={2825--2830},
  year={2011}
}
"""


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




						"""simple docstring"""




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												return datasets.MetricInfo(
												    description=_DESCRIPTION	,  citation=_CITATION	,  inputs_description=_KWARGS_DESCRIPTION	,  features=datasets.Features(
												        {
												            "predictions": datasets.Value("int32"      ),
												            "references": datasets.Value("int32"      ),
												        }      )	,  reference_urls=[
												        "https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html"
												    ]	,  )




						def 		UpperCAmelCase_	(       self	,  snake_case__	,  snake_case__	,  snake_case__=None      ):
												'''simple docstring'''
												return {
												    "matthews_correlation": float(matthews_corrcoef(snake_case__	,  snake_case__	,  sample_weight=snake_case__      )      ),
												}














"""simple docstring"""







import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / """utils"""))

from test_module.custom_configuration import CustomConfig  # noqa E402


a			:    List[str]				 =		{
    """return_dict""": False,
    """output_hidden_states""": True,
    """output_attentions""": True,
    """torchscript""": True,
    """torch_dtype""": """float16""",
    """use_bfloat16""": True,
    """tf_legacy_loss""": True,
    """pruned_heads""": {"""a""": 1},
    """tie_word_embeddings""": False,
    """is_decoder""": True,
    """cross_attention_hidden_size""": 128,
    """add_cross_attention""": True,
    """tie_encoder_decoder""": True,
    """max_length""": 50,
    """min_length""": 3,
    """do_sample""": True,
    """early_stopping""": True,
    """num_beams""": 3,
    """num_beam_groups""": 3,
    """diversity_penalty""": 0.5,
    """temperature""": 2.0,
    """top_k""": 10,
    """top_p""": 0.7,
    """typical_p""": 0.2,
    """repetition_penalty""": 0.8,
    """length_penalty""": 0.8,
    """no_repeat_ngram_size""": 5,
    """encoder_no_repeat_ngram_size""": 5,
    """bad_words_ids""": [1, 2, 3],
    """num_return_sequences""": 3,
    """chunk_size_feed_forward""": 5,
    """output_scores""": True,
    """return_dict_in_generate""": True,
    """forced_bos_token_id""": 2,
    """forced_eos_token_id""": 3,
    """remove_invalid_values""": True,
    """architectures""": ["""BertModel"""],
    """finetuning_task""": """translation""",
    """id2label""": {0: """label"""},
    """label2id""": {"""label""": """0"""},
    """tokenizer_class""": """BertTokenizerFast""",
    """prefix""": """prefix""",
    """bos_token_id""": 6,
    """pad_token_id""": 7,
    """eos_token_id""": 8,
    """sep_token_id""": 9,
    """decoder_start_token_id""": 10,
    """exponential_decay_length_penalty""": (5, 1.01),
    """suppress_tokens""": [0, 1],
    """begin_suppress_tokens""": 2,
    """task_specific_params""": {"""translation""": """some_params"""},
    """problem_type""": """regression""",
}


@is_staging_test
class    __UpperCAmelCase(       unittest.TestCase							):




						"""simple docstring"""




						@classmethod
						def 		UpperCAmelCase_	(       cls      ):
												'''simple docstring'''
												lowercase__    :				Union[str, Any]=	TOKEN
												HfFolder.save_token(snake_case__      )




						@classmethod
						def 		UpperCAmelCase_	(       cls      ):
												'''simple docstring'''
												try:
																		delete_repo(token=cls._token	,  repo_id="test-config"      )
												except HTTPError:
																		pass

												try:
																		delete_repo(token=cls._token	,  repo_id="valid_org/test-config-org"      )
												except HTTPError:
																		pass

												try:
																		delete_repo(token=cls._token	,  repo_id="test-dynamic-config"      )
												except HTTPError:
																		pass




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Union[str, Any]=	BertConfig(
												    vocab_size=99	,  hidden_size=32	,  num_hidden_layers=5	,  num_attention_heads=4	,  intermediate_size=37      )
												config.push_to_hub("test-config"	,  use_auth_token=self._token      )

												lowercase__    :				List[Any]=	BertConfig.from_pretrained(F'''{USER}/test-config'''      )
												for k, v in config.to_dict().items():
																		if k != "transformers_version":
																								self.assertEqual(snake_case__	,  getattr(snake_case__	,  snake_case__      )      )

        # Reset repo
												delete_repo(token=self._token	,  repo_id="test-config"      )

												# Push to hub via save_pretrained
												with tempfile.TemporaryDirectory() as tmp_dir:
																		config.save_pretrained(snake_case__	,  repo_id="test-config"	,  push_to_hub=snake_case__	,  use_auth_token=self._token      )

												lowercase__    :				int=	BertConfig.from_pretrained(F'''{USER}/test-config'''      )
												for k, v in config.to_dict().items():
																		if k != "transformers_version":
																								self.assertEqual(snake_case__	,  getattr(snake_case__	,  snake_case__      )      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Optional[int]=	BertConfig(
												    vocab_size=99	,  hidden_size=32	,  num_hidden_layers=5	,  num_attention_heads=4	,  intermediate_size=37      )
												config.push_to_hub("valid_org/test-config-org"	,  use_auth_token=self._token      )

												lowercase__    :				Optional[Any]=	BertConfig.from_pretrained("valid_org/test-config-org"      )
												for k, v in config.to_dict().items():
																		if k != "transformers_version":
																								self.assertEqual(snake_case__	,  getattr(snake_case__	,  snake_case__      )      )

        # Reset repo
												delete_repo(token=self._token	,  repo_id="valid_org/test-config-org"      )

												# Push to hub via save_pretrained
												with tempfile.TemporaryDirectory() as tmp_dir:
																		config.save_pretrained(
																		    snake_case__	,  repo_id="valid_org/test-config-org"	,  push_to_hub=snake_case__	,  use_auth_token=self._token      )

												lowercase__    :				Any=	BertConfig.from_pretrained("valid_org/test-config-org"      )
												for k, v in config.to_dict().items():
																		if k != "transformers_version":
																								self.assertEqual(snake_case__	,  getattr(snake_case__	,  snake_case__      )      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												CustomConfig.register_for_auto_class()
												lowercase__    :				Union[str, Any]=	CustomConfig(attribute=42      )

												config.push_to_hub("test-dynamic-config"	,  use_auth_token=self._token      )

												# This has added the proper auto_map field to the config
												self.assertDictEqual(config.auto_map	,  {"AutoConfig": "custom_configuration.CustomConfig"}      )

												lowercase__    :				List[str]=	AutoConfig.from_pretrained(F'''{USER}/test-dynamic-config'''	,  trust_remote_code=snake_case__      )
												# Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
												self.assertEqual(new_config.__class__.__name__	,  "CustomConfig"      )
												self.assertEqual(new_config.attribute	,  42      )


class    __UpperCAmelCase(       unittest.TestCase							):




						"""simple docstring"""




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Dict=	GPTaConfig()

												# attempt to modify each of int/float/bool/str config records and verify they were updated
												lowercase__    :				str=	c.n_embd + 1  # int
												lowercase__    :				Tuple=	c.resid_pdrop + 1.0  # float
												lowercase__    :				Union[str, Any]=	not c.scale_attn_weights  # bool
												lowercase__    :				Optional[Any]=	c.summary_type + "foo"  # str
												c.update_from_string(
												    F'''n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}'''      )
												self.assertEqual(snake_case__	,  c.n_embd	,  "mismatch for key: n_embd"      )
												self.assertEqual(snake_case__	,  c.resid_pdrop	,  "mismatch for key: resid_pdrop"      )
												self.assertEqual(snake_case__	,  c.scale_attn_weights	,  "mismatch for key: scale_attn_weights"      )
												self.assertEqual(snake_case__	,  c.summary_type	,  "mismatch for key: summary_type"      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Optional[Any]=	PretrainedConfig()
												lowercase__    :				List[str]=	[key for key in base_config.__dict__ if key not in config_common_kwargs]
												# If this part of the test fails, you have arguments to addin config_common_kwargs above.
												self.assertListEqual(
												    snake_case__	,  ["is_encoder_decoder", "_name_or_path", "_commit_hash", "transformers_version"]      )
												lowercase__    :				Tuple=	[key for key, value in config_common_kwargs.items() if value == getattr(snake_case__	,  snake_case__      )]
												if len(snake_case__      ) > 0:
																		raise ValueError(
																		    "The following keys are set with the default values in"
																		    " `test_configuration_common.config_common_kwargs` pick another value for them:"
																		    F''' {', '.join(snake_case__      )}.'''      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												with self.assertRaises(snake_case__      ):
																		# config is in subfolder, the following should not work without specifying the subfolder
																		lowercase__    :				Optional[int]=	BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"      )

												lowercase__    :				Optional[Any]=	BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"	,  subfolder="bert"      )

												self.assertIsNotNone(snake_case__      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												# A mock response for an HTTP head request to emulate server down
												lowercase__    :				str=	mock.Mock()
												lowercase__    :				Optional[Any]=	500
												lowercase__    :				Any=	{}
												lowercase__    :				Tuple=	HTTPError
												lowercase__    :				List[Any]=	{}

												# Download this model to make sure it's in the cache.
												lowercase__    :				Any=	BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert"      )

												# Under the mock environment we get a 500 error when trying to reach the model.
												with mock.patch("requests.Session.request"	,  return_value=snake_case__      ) as mock_head:
																		lowercase__    :				Any=	BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert"      )
																		# This check we did call the fake head request
																		mock_head.assert_called()




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												# This test is for deprecated behavior and can be removed in v5
												lowercase__    :				Optional[Any]=	BertConfig.from_pretrained(
												    "https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				int=	AutoConfig.from_pretrained("bert-base-cased"      )
												lowercase__    :				Optional[int]=	["config.4.0.0.json"]

												with tempfile.TemporaryDirectory() as tmp_dir:
																		configuration.save_pretrained(snake_case__      )
																		lowercase__    :				List[Any]=	2
																		json.dump(configuration.to_dict()	,  open(os.path.join(snake_case__	,  "config.4.0.0.json"      )	,  "w"      )      )

																		# This should pick the new configuration file as the version of Transformers is > 4.0.0
																		lowercase__    :				int=	AutoConfig.from_pretrained(snake_case__      )
																		self.assertEqual(new_configuration.hidden_size	,  2      )

																		# Will need to be adjusted if we reach v42 and this test is still here.
																		# Should pick the old configuration file as the version of Transformers is < 4.42.0
																		lowercase__    :				Optional[int]=	["config.42.0.0.json"]
																		lowercase__    :				int=	768
																		configuration.save_pretrained(snake_case__      )
																		shutil.move(os.path.join(snake_case__	,  "config.4.0.0.json"      )	,  os.path.join(snake_case__	,  "config.42.0.0.json"      )      )
																		lowercase__    :				Optional[Any]=	AutoConfig.from_pretrained(snake_case__      )
																		self.assertEqual(new_configuration.hidden_size	,  768      )




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												# This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
												lowercase__    :				Optional[Any]=	"hf-internal-testing/test-two-configs"

												import transformers as new_transformers

												lowercase__    :				Optional[Any]=	"v4.0.0"
												lowercase__,     lowercase__    :				str=	new_transformers.models.auto.AutoConfig.from_pretrained(
												    snake_case__	,  return_unused_kwargs=snake_case__      )
												self.assertEqual(new_configuration.hidden_size	,  2      )
												# This checks `_configuration_file` ia not kept in the kwargs by mistake.
												self.assertDictEqual(snake_case__	,  {}      )

												# Testing an older version by monkey-patching the version in the module it's used.
												import transformers as old_transformers

												lowercase__    :				Dict=	"v3.0.0"
												lowercase__    :				Tuple=	old_transformers.models.auto.AutoConfig.from_pretrained(snake_case__      )
												self.assertEqual(old_configuration.hidden_size	,  768      )






