
"""simple docstring"""





import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch
				from torch import nn

				from transformers import RegNetForImageClassification, RegNetModel
				from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor






class     _UpperCAmelCase:



		def __init__(					self				,		__a				,		__a=3				,		__a=32				,		__a=3				,		__a=10				,		__a=[10, 20, 30, 40]				,		__a=[1, 1, 2, 1]				,		__a=True				,		__a=True				,		__a="relu"				,		__a=3				,		__a=None				,		)       ->       Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  parent
							_UpperCamelCase							 =  batch_size
							_UpperCamelCase							 =  image_size
							_UpperCamelCase							 =  num_channels
							_UpperCamelCase							 =  embeddings_size
							_UpperCamelCase							 =  hidden_sizes
							_UpperCamelCase							 =  depths
							_UpperCamelCase							 =  is_training
							_UpperCamelCase							 =  use_labels
							_UpperCamelCase							 =  hidden_act
							_UpperCamelCase							 =  num_labels
							_UpperCamelCase							 =  scope
							_UpperCamelCase							 =  len(__a)



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

							_UpperCamelCase							 =  None
							if self.use_labels:
												_UpperCamelCase							 =  ids_tensor([self.batch_size]				,		self.num_labels)

							_UpperCamelCase							 =  self.get_config()

							return config, pixel_values, labels



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							return RegNetConfig(
							    num_channels=self.num_channels				,		embeddings_size=self.embeddings_size				,		hidden_sizes=self.hidden_sizes				,		depths=self.depths				,		hidden_act=self.hidden_act				,		num_labels=self.num_labels				,		)



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a)       ->       Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  RegNetModel(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase							 =  model(__a)
							# expected last hidden states: B, C, H // 32, W // 32
							self.parent.assertEqual(
							    result.last_hidden_state.shape				,		(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)				,		)



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a)       ->       Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  self.num_labels
							_UpperCamelCase							 =  RegNetForImageClassification(__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase							 =  model(__a				,		labels=__a)
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.num_labels))




		def 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''simple docstring'''
							_UpperCamelCase							 =  self.prepare_config_and_inputs()
							_UpperCamelCase ,  _UpperCamelCase ,  _UpperCamelCase							 =  config_and_inputs
							_UpperCamelCase							 =  {'''pixel_values''': pixel_values}
							return config, inputs_dict






@require_torch
class     _UpperCAmelCase(    lowerCamelCase      ,     lowerCamelCase      ,     unittest.TestCase	):
		lowercase__						=      (RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
		lowercase__						=      (
		    {'feature-extraction': RegNetModel, 'image-classification': RegNetForImageClassification}
		    if is_torch_available()
		    else {}
		)

		lowercase__						=      False
		lowercase__						=      False
		lowercase__						=      False
		lowercase__						=      False



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






							'''simple docstring'''
							_UpperCamelCase							 =  RegNetModelTester(self)
							_UpperCamelCase							 =  ConfigTester(self				,		config_class=__a				,		has_text_modality=__a)



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							self.create_and_test_config_common_properties()
							self.config_tester.create_and_test_config_to_json_string()
							self.config_tester.create_and_test_config_to_json_file()
							self.config_tester.create_and_test_config_from_and_save_pretrained()
							self.config_tester.create_and_test_config_with_num_labels()
							self.config_tester.check_config_can_be_init_without_params()
							self.config_tester.check_config_arguments_init()



		def 						UpperCAmelCase							(					self)       ->       List[Any]:






							'''simple docstring'''
							return



		@unittest.skip(reason='''RegNet does not use inputs_embeds''')
		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							pass



		@unittest.skip(reason='''RegNet does not support input and output embeddings''')
		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							pass



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase ,  _UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												_UpperCamelCase							 =  model_class(__a)
												_UpperCamelCase							 =  inspect.signature(model.forward)
												# signature.parameters is an OrderedDict => so arg_names order is deterministic
												_UpperCamelCase							 =  [*signature.parameters.keys()]

												_UpperCamelCase							 =  ['''pixel_values''']
												self.assertListEqual(arg_names[:1]				,		__a)



		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__a)



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase ,  _UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												_UpperCamelCase							 =  model_class(config=__a)
												for name, module in model.named_modules():
																	if isinstance(__a				,		(nn.BatchNormad, nn.GroupNorm)):
																						self.assertTrue(
																						    torch.all(module.weight == 1)				,		msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''				,		)
																						self.assertTrue(
																						    torch.all(module.bias == 0)				,		msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''				,		)



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							def check_hidden_states_output(__a				,		__a				,		__a):
												_UpperCamelCase							 =  model_class(__a)
												model.to(__a)
												model.eval()

												with torch.no_grad():
																	_UpperCamelCase							 =  model(**self._prepare_for_class(__a				,		__a))

												_UpperCamelCase							 =  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

												_UpperCamelCase							 =  self.model_tester.num_stages
												self.assertEqual(len(__a)				,		expected_num_stages + 1)

												# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
												self.assertListEqual(
												    list(hidden_states[0].shape[-2:])				,		[self.model_tester.image_size // 2, self.model_tester.image_size // 2]				,		)

							_UpperCamelCase ,  _UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()
							_UpperCamelCase							 =  ['''basic''', '''bottleneck''']
							for model_class in self.all_model_classes:
												for layer_type in layers_type:
																	_UpperCamelCase							 =  layer_type
																	_UpperCamelCase							 =  True
																	check_hidden_states_output(__a				,		__a				,		__a)

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	_UpperCamelCase							 =  True

																	check_hidden_states_output(__a				,		__a				,		__a)



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*__a)




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






							'''simple docstring'''
							for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase							 =  RegNetModel.from_pretrained(__a)
												self.assertIsNotNone(__a)





def       lowerCamelCase__		(			)							->		List[str]:


					"""simple docstring"""





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






@require_torch
@require_vision
class     _UpperCAmelCase(    unittest.TestCase	):



		@cached_property
		def 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''simple docstring'''
							return (
							    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0])
							    if is_vision_available()
							    else None
							)




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






							'''simple docstring'''
							_UpperCamelCase							 =  RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(__a)

							_UpperCamelCase							 =  self.default_image_processor
							_UpperCamelCase							 =  prepare_img()
							_UpperCamelCase							 =  image_processor(images=__a				,		return_tensors='''pt''').to(__a)

							# forward pass
							with torch.no_grad():
												_UpperCamelCase							 =  model(**__a)

							# verify the logits
							_UpperCamelCase							 =  torch.Size((1, 10_00))
							self.assertEqual(outputs.logits.shape				,		__a)

							_UpperCamelCase							 =  torch.tensor([-0.4180, -1.5051, -3.4836]).to(__a)

							self.assertTrue(torch.allclose(outputs.logits[0, :3]				,		__a				,		atol=1e-4))








"""simple docstring"""





from sklearn.metrics import matthews_corrcoef

import datasets


_a														=		"""
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														=		"""
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														=		"""\
@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)       ->       List[Any]:






							'''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				,		__a				,		__a				,		__a=None)       ->       Dict:






							'''simple docstring'''
							return {
							    "matthews_correlation": float(matthews_corrcoef(__a				,		__a				,		sample_weight=__a)),
							}






