
from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask


if is_tf_available():
     import tensorflow as tf

     from transformers import TFBlipTextModel
     from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST

class    _a				:





       """simple docstring"""




       def __init__(							self       ,							A__       ,							A__=12       ,							A__=7       ,							A__=True       ,							A__=True       ,							A__=True       ,							A__=99       ,							A__=32       ,							A__=32       ,							A__=2       ,							A__=4       ,							A__=37       ,							A__=0.1       ,							A__=0.1       ,							A__=5_12       ,							A__=0.02       ,							A__=0       ,							A__=None       ,							)    ->			List[str]:
          _SCREAMING_SNAKE_CASE      =				parent
          _SCREAMING_SNAKE_CASE      =				batch_size
          _SCREAMING_SNAKE_CASE      =				seq_length
          _SCREAMING_SNAKE_CASE      =				is_training
          _SCREAMING_SNAKE_CASE      =				use_input_mask
          _SCREAMING_SNAKE_CASE      =				use_labels
          _SCREAMING_SNAKE_CASE      =				vocab_size
          _SCREAMING_SNAKE_CASE      =				hidden_size
          _SCREAMING_SNAKE_CASE      =				projection_dim
          _SCREAMING_SNAKE_CASE      =				num_hidden_layers
          _SCREAMING_SNAKE_CASE      =				num_attention_heads
          _SCREAMING_SNAKE_CASE      =				intermediate_size
          _SCREAMING_SNAKE_CASE      =				dropout
          _SCREAMING_SNAKE_CASE      =				attention_dropout
          _SCREAMING_SNAKE_CASE      =				max_position_embeddings
          _SCREAMING_SNAKE_CASE      =				initializer_range
          _SCREAMING_SNAKE_CASE      =				scope
          _SCREAMING_SNAKE_CASE      =				bos_token_id






       def        UpperCamelCase				(							self      )    ->			Union[str, Any]:
          _SCREAMING_SNAKE_CASE      =				ids_tensor([self.batch_size, self.seq_length]       ,							self.vocab_size      )

          _SCREAMING_SNAKE_CASE      =				None
          if self.use_input_mask:
             _SCREAMING_SNAKE_CASE      =				random_attention_mask([self.batch_size, self.seq_length]      )

          if input_mask is not None:
             _SCREAMING_SNAKE_CASE      =				input_mask.numpy()
             _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				input_mask.shape
             _SCREAMING_SNAKE_CASE      =				np.random.randint(1       ,							seq_length - 1       ,							size=(batch_size,)      )
             for batch_idx, start_index in enumerate(snake_case__      ):
                _SCREAMING_SNAKE_CASE      =				1
                _SCREAMING_SNAKE_CASE      =				0

          _SCREAMING_SNAKE_CASE      =				self.get_config()

          return config, input_ids, tf.convert_to_tensor(snake_case__      )






       def        UpperCamelCase				(							self      )    ->			Optional[Any]:
          return BlipTextConfig(
              vocab_size=self.vocab_size       ,							hidden_size=self.hidden_size       ,							projection_dim=self.projection_dim       ,							num_hidden_layers=self.num_hidden_layers       ,							num_attention_heads=self.num_attention_heads       ,							intermediate_size=self.intermediate_size       ,							dropout=self.dropout       ,							attention_dropout=self.attention_dropout       ,							max_position_embeddings=self.max_position_embeddings       ,							initializer_range=self.initializer_range       ,							bos_token_id=self.bos_token_id       ,							)






       def        UpperCamelCase				(							self       ,							A__       ,							A__       ,							A__      )    ->			Dict:
          _SCREAMING_SNAKE_CASE      =				TFBlipTextModel(config=snake_case__      )
          _SCREAMING_SNAKE_CASE      =				model(snake_case__       ,							attention_mask=snake_case__       ,							training=snake_case__      )
          _SCREAMING_SNAKE_CASE      =				model(snake_case__       ,							training=snake_case__      )
          self.parent.assertEqual(result.last_hidden_state.shape       ,							(self.batch_size, self.seq_length, self.hidden_size)      )
          self.parent.assertEqual(result.pooler_output.shape       ,							(self.batch_size, self.hidden_size)      )






       def        UpperCamelCase				(							self      )    ->			str:
          _SCREAMING_SNAKE_CASE      =				self.prepare_config_and_inputs()
          _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				config_and_inputs
          _SCREAMING_SNAKE_CASE      =				{"""input_ids""": input_ids, """attention_mask""": input_mask}
          return config, inputs_dict






@require_tf
class    _a				(__a  ,					unittest.TestCase):





       """simple docstring"""




       SCREAMING_SNAKE_CASE      =  (TFBlipTextModel,) if is_tf_available() else ()
       SCREAMING_SNAKE_CASE      =  False
       SCREAMING_SNAKE_CASE      =  False
       SCREAMING_SNAKE_CASE      =  False






       def        UpperCamelCase				(							self      )    ->			List[Any]:
          _SCREAMING_SNAKE_CASE      =				BlipTextModelTester(self      )
          _SCREAMING_SNAKE_CASE      =				ConfigTester(self       ,							config_class=snake_case__       ,							hidden_size=37      )






       def        UpperCamelCase				(							self      )    ->			int:
          self.config_tester.run_common_tests()






       def        UpperCamelCase				(							self      )    ->			List[Any]:
          _SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case__      )






       def        UpperCamelCase				(							self      )    ->			Tuple:
          pass






       def        UpperCamelCase				(							self      )    ->			int:
          pass






       @unittest.skip(reason="""Blip does not use inputs_embeds"""      )
       def        UpperCamelCase				(							self      )    ->			int:
          pass






       @unittest.skip(reason="""BlipTextModel has no base class and is not available in MODEL_MAPPING"""      )
       def        UpperCamelCase				(							self      )    ->			int:
          pass






       @unittest.skip(reason="""BlipTextModel has no base class and is not available in MODEL_MAPPING"""      )
       def        UpperCamelCase				(							self      )    ->			Union[str, Any]:
          pass






       @slow
       def        UpperCamelCase				(							self      )    ->			Optional[int]:
          for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _SCREAMING_SNAKE_CASE      =				TFBlipTextModel.from_pretrained(snake_case__      )
             self.assertIsNotNone(snake_case__      )






       def        UpperCamelCase				(							self       ,							A__=True      )    ->			Optional[Any]:
          super().test_pt_tf_model_equivalence(allow_missing_keys=snake_case__      )








'''simple docstring'''



from sklearn.metrics import matthews_corrcoef

import datasets


UpperCamelCase__      :		List[str]       							=  "\nCompute the Matthews correlation coefficient (MCC)\n\nThe Matthews correlation coefficient is used in machine learning as a\nmeasure of the quality of binary and multiclass classifications. It takes\ninto account true and false positives and negatives and is generally\nregarded as a balanced measure which can be used even if the classes are of\nvery different sizes. The MCC is in essence a correlation coefficient value\nbetween -1 and +1. A coefficient of +1 represents a perfect prediction, 0\nan average random prediction and -1 an inverse prediction.  The statistic\nis also known as the phi coefficient. [source: Wikipedia]\n"

UpperCamelCase__      :		List[Any]       							=  "\nArgs:\n    predictions (list of int): Predicted labels, as returned by a model.\n    references (list of int): Ground truth labels.\n    sample_weight (list of int, float, or bool): Sample weights. Defaults to `None`.\nReturns:\n    matthews_correlation (dict containing float): Matthews correlation.\nExamples:\n    Example 1, a basic example with only predictions and references as inputs:\n        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")\n        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n        ...                                     predictions=[1, 2, 2, 0, 3, 3])\n        >>> print(round(results['matthews_correlation'], 2))\n        0.54\n\n    Example 2, the same example as above, but also including sample weights:\n        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")\n        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n        ...                                     predictions=[1, 2, 2, 0, 3, 3],\n        ...                                     sample_weight=[0.5, 3, 1, 1, 1, 2])\n        >>> print(round(results['matthews_correlation'], 2))\n        0.1\n\n    Example 3, the same example as above, but with sample weights that cause a negative correlation:\n        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")\n        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n        ...                                     predictions=[1, 2, 2, 0, 3, 3],\n        ...                                     sample_weight=[0.5, 1, 0, 0, 0, 1])\n        >>> print(round(results['matthews_correlation'], 2))\n        -0.25\n"

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

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





       """simple docstring"""




       def        UpperCamelCase				(							self      )    ->			Optional[Any]:
          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      )    ->			List[str]:
          return {
              "matthews_correlation": float(matthews_corrcoef(A__       ,							A__       ,							sample_weight=A__      )      ),
          }






