





from sklearn.metrics import matthews_corrcoef

import datasets


A   : List[Any]			=				'''
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   : Dict			=				'''\
@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   A      (datasets.Metric   ):
			'''simple docstring'''




			def        a_	(      self       :   List[Any]       )     ->     List[str]:







					"""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        a_	(      self       :   List[Any]							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   List[str]=None       )     ->     Tuple:







					"""simple docstring"""






					return {
					    "matthews_correlation": float(matthews_corrcoef(__lowerCAmelCase							,     __lowerCAmelCase							,     sample_weight=__lowerCAmelCase       )       ),
					}










from __future__ import annotations

import unittest

from transformers import BlenderbotSmallConfig, BlenderbotSmallTokenizer, is_tf_available
from transformers.testing_utils import require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import TFAutoModelForSeqaSeqLM, TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel


@require_tf
class   A      :
			'''simple docstring'''




			__lowerCamelCase     :	Optional[Any]          =   BlenderbotSmallConfig
			__lowerCamelCase     :	Optional[Any]          =   {}
			__lowerCamelCase     :	List[Any]          =   '''gelu'''






			def __init__(      self       :   Dict							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   List[str]=13							,     __lowerCAmelCase       :   List[Any]=7							,     __lowerCAmelCase       :   List[str]=True							,     __lowerCAmelCase       :   List[Any]=False							,     __lowerCAmelCase       :   Union[str, Any]=99							,     __lowerCAmelCase       :   Union[str, Any]=32							,     __lowerCAmelCase       :   Any=2							,     __lowerCAmelCase       :   Optional[Any]=4							,     __lowerCAmelCase       :   Tuple=37							,     __lowerCAmelCase       :   List[Any]=0.1							,     __lowerCAmelCase       :   Optional[int]=0.1							,     __lowerCAmelCase       :   List[str]=20							,     __lowerCAmelCase       :   Union[str, Any]=2							,     __lowerCAmelCase       :   Dict=1							,     __lowerCAmelCase       :   int=0							,     )     ->     Any:







					"""simple docstring"""






					A__  				=       parent
					A__  				=       batch_size
					A__  				=       seq_length
					A__  				=       is_training
					A__  				=       use_labels
					A__  				=       vocab_size
					A__  				=       hidden_size
					A__  				=       num_hidden_layers
					A__  				=       num_attention_heads
					A__  				=       intermediate_size

					A__  				=       hidden_dropout_prob
					A__  				=       attention_probs_dropout_prob
					A__  				=       max_position_embeddings
					A__  				=       eos_token_id
					A__  				=       pad_token_id
					A__  				=       bos_token_id






			def        a_	(      self       :   Optional[Any]       )     ->     Tuple:







					"""simple docstring"""






					A__  				=       ids_tensor([self.batch_size, self.seq_length - 1]							,     self.vocab_size       )
					A__  				=       tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size       )							,     1       )
					A__  				=       tf.concat([input_ids, eos_tensor]							,     axis=1       )

					A__  				=       ids_tensor([self.batch_size, self.seq_length]							,     self.vocab_size       )

					A__  				=       self.config_cls(
					    vocab_size=self.vocab_size							,     d_model=self.hidden_size							,     encoder_layers=self.num_hidden_layers							,     decoder_layers=self.num_hidden_layers							,     encoder_attention_heads=self.num_attention_heads							,     decoder_attention_heads=self.num_attention_heads							,     encoder_ffn_dim=self.intermediate_size							,     decoder_ffn_dim=self.intermediate_size							,     dropout=self.hidden_dropout_prob							,     attention_dropout=self.attention_probs_dropout_prob							,     max_position_embeddings=self.max_position_embeddings							,     eos_token_ids=[2]							,     bos_token_id=self.bos_token_id							,     pad_token_id=self.pad_token_id							,     decoder_start_token_id=self.pad_token_id							,     **self.config_updates							,     )
					A__  				=       prepare_blenderbot_small_inputs_dict(__lowerCAmelCase							,     __lowerCAmelCase							,     __lowerCAmelCase       )
					return config, inputs_dict







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







					"""simple docstring"""






					A__  				=       TFBlenderbotSmallModel(config=__lowerCAmelCase       ).get_decoder()
					A__  				=       inputs_dict["""input_ids"""]

					A__  				=       input_ids[:1, :]
					A__  				=       inputs_dict["""attention_mask"""][:1, :]
					A__  				=       inputs_dict["""head_mask"""]
					A__  				=       1

					# first forward pass
					A__  				=       model(__lowerCAmelCase							,     attention_mask=__lowerCAmelCase							,     head_mask=__lowerCAmelCase							,     use_cache=__lowerCAmelCase       )

					A__				,      A__  				=       outputs.to_tuple()

					# create hypothetical next token and extent to next_input_ids
					A__  				=       ids_tensor((self.batch_size, 3)							,     config.vocab_size       )
					A__  				=       tf.cast(ids_tensor((self.batch_size, 3)							,     2       )							,     tf.inta       )

					# append to next input_ids and
					A__  				=       tf.concat([input_ids, next_tokens]							,     axis=-1       )
					A__  				=       tf.concat([attention_mask, next_attn_mask]							,     axis=-1       )

					A__  				=       model(__lowerCAmelCase							,     attention_mask=__lowerCAmelCase       )[0]
					A__  				=       model(__lowerCAmelCase							,     attention_mask=__lowerCAmelCase							,     past_key_values=__lowerCAmelCase       )[0]

					self.parent.assertEqual(next_tokens.shape[1]							,     output_from_past.shape[1]       )

					# select random slice
					A__  				=       int(ids_tensor((1,)							,     output_from_past.shape[-1]       )       )
					A__  				=       output_from_no_past[:, -3:, random_slice_idx]
					A__  				=       output_from_past[:, :, random_slice_idx]

					# test that outputs are equal for slice
					tf.debugging.assert_near(__lowerCAmelCase							,     __lowerCAmelCase							,     rtol=1e-3       )







def        __lowerCamelCase (							__a       :Dict   ,					__a       :Tuple   ,					__a       :List[Any]   ,					__a       :List[str]=None   ,					__a       :List[Any]=None   ,					__a       :Optional[Any]=None   ,					__a       :List[str]=None   ,					__a       :int=None   ,					)		->    Optional[Any]:






		"""simple docstring"""

		if attention_mask is None:
				A__  				=       tf.cast(tf.math.not_equal(__a   ,					config.pad_token_id   )   ,					tf.inta   )
		if decoder_attention_mask is None:
				A__  				=       tf.concat(
				    [
				        tf.ones(decoder_input_ids[:, :1].shape   ,					dtype=tf.inta   ),
				        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]   ,					config.pad_token_id   )   ,					tf.inta   ),
				    ]   ,					axis=-1   ,					)
		if head_mask is None:
				A__  				=       tf.ones((config.encoder_layers, config.encoder_attention_heads)   )
		if decoder_head_mask is None:
				A__  				=       tf.ones((config.decoder_layers, config.decoder_attention_heads)   )
		if cross_attn_head_mask is None:
				A__  				=       tf.ones((config.decoder_layers, config.decoder_attention_heads)   )
		return {
		    "input_ids": input_ids,
		    "decoder_input_ids": decoder_input_ids,
		    "attention_mask": attention_mask,
		    "decoder_attention_mask": decoder_attention_mask,
		    "head_mask": head_mask,
		    "decoder_head_mask": decoder_head_mask,
		    "cross_attn_head_mask": cross_attn_head_mask,
		}


@require_tf
class   A      (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					unittest.TestCase   ):
			'''simple docstring'''




			__lowerCamelCase     :	Tuple          =   (
			    (TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel) if is_tf_available() else ()
			)
			__lowerCamelCase     :	List[Any]          =   (TFBlenderbotSmallForConditionalGeneration,) if is_tf_available() else ()
			__lowerCamelCase     :	Tuple          =   (
			    {
			        '''conversational''': TFBlenderbotSmallForConditionalGeneration,
			        '''feature-extraction''': TFBlenderbotSmallModel,
			        '''summarization''': TFBlenderbotSmallForConditionalGeneration,
			        '''text2text-generation''': TFBlenderbotSmallForConditionalGeneration,
			        '''translation''': TFBlenderbotSmallForConditionalGeneration,
			    }
			    if is_tf_available()
			    else {}
			)
			__lowerCamelCase     :	Dict          =   True
			__lowerCamelCase     :	Optional[Any]          =   False
			__lowerCamelCase     :	Tuple          =   False






			def        a_	(      self       :   Tuple       )     ->     Optional[int]:







					"""simple docstring"""






					A__  				=       TFBlenderbotSmallModelTester(self       )
					A__  				=       ConfigTester(self							,     config_class=__lowerCAmelCase       )






			def        a_	(      self       :   List[str]       )     ->     int:







					"""simple docstring"""






					self.config_tester.run_common_tests()







			def        a_	(      self       :   List[str]       )     ->     Any:







					"""simple docstring"""






					A__  				=       self.model_tester.prepare_config_and_inputs_for_common()
					self.model_tester.check_decoder_model_past_large_inputs(*__lowerCAmelCase       )


@require_tokenizers
@require_tf
class   A      (unittest.TestCase   ):
			'''simple docstring'''




			__lowerCamelCase     :	List[str]          =   [
			    '''Social anxiety\nWow, I am never shy. Do you have anxiety?\nYes. I end up sweating and blushing and feel like '''
			    '''  i\'m going to throw up.\nand why is that?'''
			]
			__lowerCamelCase     :	Optional[int]          =   '''facebook/blenderbot_small-90M'''






			@cached_property
			def        a_	(      self       :   Optional[int]       )     ->     List[str]:







					"""simple docstring"""






					return BlenderbotSmallTokenizer.from_pretrained("""facebook/blenderbot-90M"""       )






			@cached_property
			def        a_	(      self       :   List[str]       )     ->     List[str]:







					"""simple docstring"""






					A__  				=       TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name       )
					return model







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







					"""simple docstring"""






					A__  				=       self.tokenizer(self.src_text							,     return_tensors="""tf"""       )
					A__  				=       self.model.generate(
					    model_inputs.input_ids							,     attention_mask=model_inputs.attention_mask							,     num_beams=2							,     use_cache=__lowerCAmelCase							,     )
					A__  				=       self.tokenizer.batch_decode(generated_ids.numpy()							,     skip_special_tokens=__lowerCAmelCase       )[0]
					assert generated_words in (
					    "i don't know. i just feel like i'm going to throw up. it's not fun.",
					    "i'm not sure. i just feel like i've been feeling like i have to be in a certain place",
					    "i'm not sure. i just feel like i've been in a bad situation.",
					)



