






from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

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


if is_tf_available():
					import tensorflow as tf

					from transformers import TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
					from PIL import Image

					from transformers import ViTImageProcessor
class     lowerCamelCase_					:







				def __init__(    self							,       __lowerCAmelCase							,       __lowerCAmelCase=1_3							,       __lowerCAmelCase=3_0							,       __lowerCAmelCase=2							,       __lowerCAmelCase=3							,       __lowerCAmelCase=True							,       __lowerCAmelCase=True							,       __lowerCAmelCase=3_2							,       __lowerCAmelCase=2							,       __lowerCAmelCase=4							,       __lowerCAmelCase=3_7							,       __lowerCAmelCase="gelu"							,       __lowerCAmelCase=0.1							,       __lowerCAmelCase=0.1							,       __lowerCAmelCase=1_0							,       __lowerCAmelCase=0.02							,       __lowerCAmelCase=3							,       __lowerCAmelCase=0.6							,       __lowerCAmelCase=None							,       ):
								"""simple docstring"""
								__magic_name__		:Tuple   =   parent
								__magic_name__		:List[str]   =   batch_size
								__magic_name__		:Any   =   image_size
								__magic_name__		:List[str]   =   patch_size
								__magic_name__		:Optional[int]   =   num_channels
								__magic_name__		:int   =   is_training
								__magic_name__		:Tuple   =   use_labels
								__magic_name__		:List[Any]   =   hidden_size
								__magic_name__		:Dict   =   num_hidden_layers
								__magic_name__		:Union[str, Any]   =   num_attention_heads
								__magic_name__		:Any   =   intermediate_size
								__magic_name__		:List[Any]   =   hidden_act
								__magic_name__		:Tuple   =   hidden_dropout_prob
								__magic_name__		:str   =   attention_probs_dropout_prob
								__magic_name__		:int   =   type_sequence_label_size
								__magic_name__		:Dict   =   initializer_range
								__magic_name__		:Optional[Any]   =   mask_ratio
								__magic_name__		:Any   =   scope

								# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
								# (we add 1 for the [CLS] token)
								__magic_name__		:int   =   (image_size // patch_size) ** 2
								__magic_name__		:List[Any]   =   int(math.ceil((1 - mask_ratio) * (num_patches + 1)  )  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[Any]   =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

								__magic_name__		:List[str]   =   None
								if self.use_labels:
												__magic_name__		:Tuple   =   ids_tensor([self.batch_size]							,       self.type_sequence_label_size  )

								__magic_name__		:Dict   =   self.get_config()

								return config, pixel_values, labels







				def       A						(    self  ):
								"""simple docstring"""
								return ViTMAEConfig(
								    image_size=self.image_size							,       patch_size=self.patch_size							,       num_channels=self.num_channels							,       hidden_size=self.hidden_size							,       num_hidden_layers=self.num_hidden_layers							,       num_attention_heads=self.num_attention_heads							,       intermediate_size=self.intermediate_size							,       decoder_hidden_size=self.hidden_size							,       decoder_num_hidden_layers=self.num_hidden_layers							,       decoder_num_attention_heads=self.num_attention_heads							,       decoder_intermediate_size=self.intermediate_size							,       hidden_act=self.hidden_act							,       hidden_dropout_prob=self.hidden_dropout_prob							,       attention_probs_dropout_prob=self.attention_probs_dropout_prob							,       is_decoder=__lowerCAmelCase							,       initializer_range=self.initializer_range							,       mask_ratio=self.mask_ratio							,       )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]   =   TFViTMAEModel(config=__lowerCAmelCase  )
								__magic_name__		:Union[str, Any]   =   model(__lowerCAmelCase							,       training=__lowerCAmelCase  )
								self.parent.assertEqual(result.last_hidden_state.shape							,       (self.batch_size, self.seq_length, self.hidden_size)  )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:Any   =   TFViTMAEForPreTraining(__lowerCAmelCase  )
								__magic_name__		:List[str]   =   model(__lowerCAmelCase							,       training=__lowerCAmelCase  )
								# expected sequence length = num_patches
								__magic_name__		:List[str]   =   (self.image_size // self.patch_size) ** 2
								__magic_name__		:str   =   self.patch_size**2 * self.num_channels
								self.parent.assertEqual(result.logits.shape							,       (self.batch_size, num_patches, expected_num_channels)  )

								# test greyscale images
								__magic_name__		:Optional[Any]   =   1
								__magic_name__		:Union[str, Any]   =   TFViTMAEForPreTraining(__lowerCAmelCase  )

								__magic_name__		:str   =   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
								__magic_name__		:Union[str, Any]   =   model(__lowerCAmelCase							,       training=__lowerCAmelCase  )
								__magic_name__		:List[str]   =   self.patch_size**2
								self.parent.assertEqual(result.logits.shape							,       (self.batch_size, num_patches, expected_num_channels)  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[str]   =   self.prepare_config_and_inputs()
								((__magic_name__)  ,					(__magic_name__)  ,					(__magic_name__))		:Tuple   =   config_and_inputs
								__magic_name__		:Optional[int]   =   {'''pixel_values''': pixel_values}
								return config, inputs_dict







@require_tf
class     lowerCamelCase_					(   lowerCamelCase      ,					lowerCamelCase      ,					unittest.TestCase			):
				a__       							=	(TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
				a__       							=	{'''feature-extraction''': TFViTMAEModel} if is_tf_available() else {}

				a__       							=	False
				a__       							=	False
				a__       							=	False
				a__       							=	False







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[str]   =   TFViTMAEModelTester(self  )
								__magic_name__		:Optional[Any]   =   ConfigTester(self							,       config_class=__lowerCAmelCase							,       has_text_modality=__lowerCAmelCase							,       hidden_size=3_7  )







				def       A						(    self  ):
								"""simple docstring"""
								self.config_tester.run_common_tests()







				@unittest.skip(reason='''ViTMAE does not use inputs_embeds'''  )
				def       A						(    self  ):
								"""simple docstring"""
								pass







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__  ,					__magic_name__		:Optional[int]   =   self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
												__magic_name__		:Dict   =   model_class(__lowerCAmelCase  )
												self.assertIsInstance(model.get_input_embeddings()							,       (tf.keras.layers.Layer)  )
												__magic_name__		:Dict   =   model.get_output_embeddings()
												self.assertTrue(x is None or isinstance(__lowerCAmelCase							,       tf.keras.layers.Layer  )  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__  ,					__magic_name__		:Optional[Any]   =   self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
												__magic_name__		:Optional[int]   =   model_class(__lowerCAmelCase  )
												__magic_name__		:Dict   =   inspect.signature(model.call  )
												# signature.parameters is an OrderedDict => so arg_names order is deterministic
												__magic_name__		:Optional[Any]   =   [*signature.parameters.keys()]

												__magic_name__		:Union[str, Any]   =   ['''pixel_values''']
												self.assertListEqual(arg_names[:1]							,       __lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Any   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[str]   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_pretraining(*__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								# make the mask reproducible
								np.random.seed(2  )

								__magic_name__  ,					__magic_name__		:List[Any]   =   self.model_tester.prepare_config_and_inputs_for_common()

								__magic_name__		:Any   =   int((config.image_size // config.patch_size) ** 2  )
								__magic_name__		:str   =   np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )

								for model_class in self.all_model_classes:
												__magic_name__		:int   =   model_class(__lowerCAmelCase  )
												__magic_name__		:str   =   self._prepare_for_class(__lowerCAmelCase							,       __lowerCAmelCase  )

												__magic_name__		:str   =   model(__lowerCAmelCase							,       noise=__lowerCAmelCase  )

												__magic_name__		:str   =   copy.deepcopy(self._prepare_for_class(__lowerCAmelCase							,       __lowerCAmelCase  )  )
												__magic_name__		:Optional[Any]   =   model(**__lowerCAmelCase							,       noise=__lowerCAmelCase  )
												__magic_name__		:Any   =   outputs_dict[0].numpy()
												__magic_name__		:Any   =   outputs_keywords[0].numpy()

												self.assertLess(np.sum(np.abs(output_dict - output_keywords  )  )							,       1E-6  )







				def       A						(    self  ):
								"""simple docstring"""
								# make the mask reproducible
								np.random.seed(2  )

								__magic_name__  ,					__magic_name__		:Any   =   self.model_tester.prepare_config_and_inputs_for_common()

								__magic_name__		:str   =   int((config.image_size // config.patch_size) ** 2  )
								__magic_name__		:Optional[Any]   =   np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )

								def prepare_numpy_arrays(__lowerCAmelCase  ):
												__magic_name__		:Dict   =   {}
												for k, v in inputs_dict.items():
																if tf.is_tensor(__lowerCAmelCase  ):
																				__magic_name__		:Optional[int]   =   v.numpy()
																else:
																				__magic_name__		:Union[str, Any]   =   np.array(__lowerCAmelCase  )

												return inputs_np_dict

								for model_class in self.all_model_classes:
												__magic_name__		:Union[str, Any]   =   model_class(__lowerCAmelCase  )

												__magic_name__		:Optional[Any]   =   self._prepare_for_class(__lowerCAmelCase							,       __lowerCAmelCase  )
												__magic_name__		:Any   =   prepare_numpy_arrays(__lowerCAmelCase  )

												__magic_name__		:Dict   =   model(__lowerCAmelCase							,       noise=__lowerCAmelCase  )
												__magic_name__		:Dict   =   model(**__lowerCAmelCase							,       noise=__lowerCAmelCase  )
												self.assert_outputs_same(__lowerCAmelCase							,       __lowerCAmelCase  )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								# make masks reproducible
								np.random.seed(2  )

								__magic_name__		:Tuple   =   int((tf_model.config.image_size // tf_model.config.patch_size) ** 2  )
								__magic_name__		:Optional[int]   =   np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )
								__magic_name__		:List[str]   =   tf.constant(__lowerCAmelCase  )

								# Add `noise` argument.
								# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
								__magic_name__		:List[Any]   =   tf_noise

								super().check_pt_tf_models(__lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								# make mask reproducible
								np.random.seed(2  )

								__magic_name__  ,					__magic_name__		:Union[str, Any]   =   self.model_tester.prepare_config_and_inputs_for_common()

								__magic_name__		:int   =   {
								    module_member
								    for model_class in self.all_model_classes
								    for module in (import_module(model_class.__module__  ),)
								    for module_member_name in dir(__lowerCAmelCase  )
								    if module_member_name.endswith('''MainLayer'''  )
								    # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
								    and module_member_name[: -len('''MainLayer'''  )] == model_class.__name__[: -len('''Model'''  )]
								    for module_member in (getattr(__lowerCAmelCase							,       __lowerCAmelCase  ),)
								    if isinstance(__lowerCAmelCase							,       __lowerCAmelCase  )
								    and tf.keras.layers.Layer in module_member.__bases__
								    and getattr(__lowerCAmelCase							,       '''_keras_serializable'''							,       __lowerCAmelCase  )
								}

								__magic_name__		:Dict   =   int((config.image_size // config.patch_size) ** 2  )
								__magic_name__		:Optional[int]   =   np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )
								__magic_name__		:Dict   =   tf.convert_to_tensor(__lowerCAmelCase  )
								inputs_dict.update({'''noise''': noise}  )

								for main_layer_class in tf_main_layer_classes:
												__magic_name__		:str   =   main_layer_class(__lowerCAmelCase  )

												__magic_name__		:Optional[Any]   =   {
												    name: tf.keras.Input(tensor.shape[1:]							,       dtype=tensor.dtype  ) for name, tensor in inputs_dict.items()
												}

												__magic_name__		:List[str]   =   tf.keras.Model(__lowerCAmelCase							,       outputs=main_layer(__lowerCAmelCase  )  )
												__magic_name__		:Tuple   =   model(__lowerCAmelCase  )

												with tempfile.TemporaryDirectory() as tmpdirname:
																__magic_name__		:List[Any]   =   os.path.join(__lowerCAmelCase							,       '''keras_model.h5'''  )
																model.save(__lowerCAmelCase  )
																__magic_name__		:Dict   =   tf.keras.models.load_model(
																    __lowerCAmelCase							,       custom_objects={main_layer_class.__name__: main_layer_class}  )
																assert isinstance(__lowerCAmelCase							,       tf.keras.Model  )
																__magic_name__		:int   =   model(__lowerCAmelCase  )
																self.assert_outputs_same(__lowerCAmelCase							,       __lowerCAmelCase  )







				@slow
				def       A						(    self  ):
								"""simple docstring"""
								# make mask reproducible
								np.random.seed(2  )

								__magic_name__  ,					__magic_name__		:List[str]   =   self.model_tester.prepare_config_and_inputs_for_common()

								__magic_name__		:Dict   =   int((config.image_size // config.patch_size) ** 2  )
								__magic_name__		:List[Any]   =   np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )

								for model_class in self.all_model_classes:
												__magic_name__		:Tuple   =   model_class(__lowerCAmelCase  )
												__magic_name__		:str   =   self._prepare_for_class(__lowerCAmelCase							,       __lowerCAmelCase  )
												__magic_name__		:List[Any]   =   model(__lowerCAmelCase							,       noise=__lowerCAmelCase  )

												if model_class.__name__ == "TFViTMAEModel":
																__magic_name__		:Dict   =   outputs.last_hidden_state.numpy()
																__magic_name__		:Any   =   0
												else:
																__magic_name__		:Dict   =   outputs.logits.numpy()
																__magic_name__		:Union[str, Any]   =   0

												with tempfile.TemporaryDirectory() as tmpdirname:
																model.save_pretrained(__lowerCAmelCase							,       saved_model=__lowerCAmelCase  )
																__magic_name__		:List[str]   =   model_class.from_pretrained(__lowerCAmelCase  )
																__magic_name__		:int   =   model(__lowerCAmelCase							,       noise=__lowerCAmelCase  )

																if model_class.__name__ == "TFViTMAEModel":
																				__magic_name__		:Optional[int]   =   after_outputs['''last_hidden_state'''].numpy()
																				__magic_name__		:str   =   0
																else:
																				__magic_name__		:str   =   after_outputs['''logits'''].numpy()
																				__magic_name__		:Optional[Any]   =   0

																__magic_name__		:int   =   np.amax(np.abs(out_a - out_a  )  )
																self.assertLessEqual(__lowerCAmelCase							,       1E-5  )







				def       A						(    self  ):
								"""simple docstring"""
								# make mask reproducible
								np.random.seed(2  )

								__magic_name__  ,					__magic_name__		:Dict   =   self.model_tester.prepare_config_and_inputs_for_common()

								__magic_name__		:List[str]   =   int((config.image_size // config.patch_size) ** 2  )
								__magic_name__		:List[str]   =   np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )

								for model_class in self.all_model_classes:
												__magic_name__		:Union[str, Any]   =   model_class(__lowerCAmelCase  )
												__magic_name__		:Union[str, Any]   =   self._prepare_for_class(__lowerCAmelCase							,       __lowerCAmelCase  )

												__magic_name__		:Tuple   =   model(__lowerCAmelCase							,       noise=__lowerCAmelCase  )
												__magic_name__		:Tuple   =   model.get_config()
												# make sure that returned config is jsonifiable, which is required by keras
												json.dumps(__lowerCAmelCase  )
												__magic_name__		:List[Any]   =   model_class.from_config(model.get_config()  )
												# make sure it also accepts a normal config
												__magic_name__		:Union[str, Any]   =   model_class.from_config(model.config  )
												__magic_name__		:Dict   =   new_model(__lowerCAmelCase  )  # Build model
												new_model.set_weights(model.get_weights()  )
												__magic_name__		:Any   =   new_model(__lowerCAmelCase							,       noise=__lowerCAmelCase  )

												self.assert_outputs_same(__lowerCAmelCase							,       __lowerCAmelCase  )







				@unittest.skip(
				    reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.'''  )
				def       A						(    self  ):
								"""simple docstring"""
								pass







				@unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'''  )
				def       A						(    self  ):
								"""simple docstring"""
								pass







				@slow
				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Any   =   TFViTMAEModel.from_pretrained('''google/vit-base-patch16-224'''  )
								self.assertIsNotNone(__lowerCAmelCase  )







def   __lowercase       (			):







				"""simple docstring"""






				__magic_name__		:Tuple   =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
				return image

@require_tf
@require_vision
class     lowerCamelCase_					(   unittest.TestCase			):







				@cached_property
				def       A						(    self  ):
								"""simple docstring"""
								return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base'''  ) if is_vision_available() else None







				@slow
				def       A						(    self  ):
								"""simple docstring"""
								# make random mask reproducible across the PT and TF model
								np.random.seed(2  )

								__magic_name__		:str   =   TFViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base'''  )

								__magic_name__		:Tuple   =   self.default_image_processor
								__magic_name__		:Dict   =   prepare_img()
								__magic_name__		:Dict   =   image_processor(images=__lowerCAmelCase							,       return_tensors='''tf'''  )

								# prepare a noise vector that will be also used for testing the TF model
								# (this way we can ensure that the PT and TF models operate on the same inputs)
								__magic_name__		:Tuple   =   ViTMAEConfig()
								__magic_name__		:Union[str, Any]   =   int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2  )
								__magic_name__		:List[str]   =   np.random.uniform(size=(1, num_patches)  )

								# forward pass
								__magic_name__		:str   =   model(**__lowerCAmelCase							,       noise=__lowerCAmelCase  )

								# verify the logits
								__magic_name__		:List[Any]   =   tf.convert_to_tensor([1, 1_9_6, 7_6_8]  )
								self.assertEqual(outputs.logits.shape							,       __lowerCAmelCase  )

								__magic_name__		:int   =   tf.convert_to_tensor(
								    [[-0.0548, -1.7023, -0.9325], [0.3721, -0.5670, -0.2233], [0.8235, -1.3878, -0.3524]]  )

								tf.debugging.assert_near(outputs.logits[0, :3, :3]							,       __lowerCAmelCase							,       atol=1E-4  )













"""simple docstring"""






from sklearn.metrics import matthews_corrcoef

import datasets


__UpperCAmelCase						=			'''
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]
'''

__UpperCAmelCase						=			'''
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
'''

__UpperCAmelCase						=			'''\
@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  ):
				def       UpperCAmelCase      (		self    :			Optional[int]    )	->	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       UpperCAmelCase      (		self    :			Tuple	, a_    :			Optional[Any]	, a_    :			Optional[Any]	, a_    :			Any=None    )	->	Union[str, Any]:



							'''simple docstring'''



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