






"""simple docstring"""





import datasets


A__					: Tuple=	"""\
@InProceedings{conneau2018xnli,
  author = \"Conneau, Alexis
                 and Rinott, Ruty
                 and Lample, Guillaume
                 and Williams, Adina
                 and Bowman, Samuel R.
                 and Schwenk, Holger
                 and Stoyanov, Veselin\",
  title = \"XNLI: Evaluating Cross-lingual Sentence Representations\",
  booktitle = \"Proceedings of the 2018 Conference on Empirical Methods
               in Natural Language Processing\",
  year = \"2018\",
  publisher = \"Association for Computational Linguistics\",
  location = \"Brussels, Belgium\",
}
"""

A__					: Any=	"""\
XNLI is a subset of a few thousand examples from MNLI which has been translated
into a 14 different languages (some low-ish resource). As with MNLI, the goal is
to predict textual entailment (does sentence A imply/contradict/neither sentence
B) and is a classification task (given two sentences, predict one of three
labels).
"""

A__					: int=	"""
Computes XNLI score which is just simple accuracy.
Args:
    predictions: Predicted labels.
    references: Ground truth labels.
Returns:
    'accuracy': accuracy
Examples:

    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> xnli_metric = datasets.load_metric(\"xnli\")
    >>> results = xnli_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}
"""







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)					->	Optional[Any]:
    """simple docstring"""

    return (preds == labels).mean()





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

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       return datasets.MetricInfo(
           description=_DESCRIPTION ,				citation=_CITATION ,				inputs_description=_KWARGS_DESCRIPTION ,				features=datasets.Features(
               {
                   'predictions': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'      ),
                   'references': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'      ),
               }      ) ,				codebase_urls=[] ,				reference_urls=[] ,				format='numpy' ,				)







   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_      )		->       int:
       return {"accuracy": simple_accuracy(snake_case_ ,				snake_case_      )}












"""simple docstring"""





import inspect
import unittest

import numpy as np

from transformers import BeitConfig
from transformers.testing_utils import require_flax, require_vision, slow
from transformers.utils import cached_property, is_flax_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor


if is_flax_available():
  import jax

  from transformers import FlaxBeitForImageClassification, FlaxBeitForMaskedImageModeling, FlaxBeitModel

if is_vision_available():
  from PIL import Image

  from transformers import BeitImageProcessor
class    __lowerCamelCase    (  unittest.TestCase  ):

   def __init__(					self ,				snake_case_ ,				snake_case_=100 ,				snake_case_=13 ,				snake_case_=30 ,				snake_case_=2 ,				snake_case_=3 ,				snake_case_=True ,				snake_case_=True ,				snake_case_=32 ,				snake_case_=5 ,				snake_case_=4 ,				snake_case_=37 ,				snake_case_="gelu" ,				snake_case_=0.1 ,				snake_case_=0.1 ,				snake_case_=10 ,				snake_case_=0.02 ,				snake_case_=3 ,				)		->       Optional[int]:
       UpperCamelCase__         =    parent
       UpperCamelCase__         =    vocab_size
       UpperCamelCase__         =    batch_size
       UpperCamelCase__         =    image_size
       UpperCamelCase__         =    patch_size
       UpperCamelCase__         =    num_channels
       UpperCamelCase__         =    is_training
       UpperCamelCase__         =    use_labels
       UpperCamelCase__         =    hidden_size
       UpperCamelCase__         =    num_hidden_layers
       UpperCamelCase__         =    num_attention_heads
       UpperCamelCase__         =    intermediate_size
       UpperCamelCase__         =    hidden_act
       UpperCamelCase__         =    hidden_dropout_prob
       UpperCamelCase__         =    attention_probs_dropout_prob
       UpperCamelCase__         =    type_sequence_label_size
       UpperCamelCase__         =    initializer_range

       # in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
       UpperCamelCase__         =    (image_size // patch_size) ** 2
       UpperCamelCase__         =    num_patches + 1

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       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.type_sequence_label_size      )

       UpperCamelCase__         =    BeitConfig(
           vocab_size=self.vocab_size ,				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 ,				hidden_act=self.hidden_act ,				hidden_dropout_prob=self.hidden_dropout_prob ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob ,				is_decoder=snake_case_ ,				initializer_range=self.initializer_range ,				)

       return config, pixel_values, labels

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[Any]:
       UpperCamelCase__         =    FlaxBeitModel(config=snake_case_      )
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.last_hidden_state.shape ,				(self.batch_size, self.seq_length, self.hidden_size)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[Any]:
       UpperCamelCase__         =    FlaxBeitForMaskedImageModeling(config=snake_case_      )
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length - 1, self.vocab_size)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[str]:
       UpperCamelCase__         =    self.type_sequence_label_size
       UpperCamelCase__         =    FlaxBeitForImageClassification(config=snake_case_      )
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.type_sequence_label_size)      )

       # test greyscale images
       UpperCamelCase__         =    1
       UpperCamelCase__         =    FlaxBeitForImageClassification(snake_case_      )

       UpperCamelCase__         =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
       UpperCamelCase__         =    model(snake_case_      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.prepare_config_and_inputs()
       (
           (
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						
       )         =    config_and_inputs
       UpperCamelCase__         =    {'pixel_values': pixel_values}
       return config, inputs_dict







@require_flax
class    __lowerCamelCase    (  _a							,	unittest.TestCase  ):
   a      :				int 						=(
       (FlaxBeitModel, FlaxBeitForImageClassification, FlaxBeitForMaskedImageModeling) if is_flax_available() else ()
   )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       None:
       UpperCamelCase__         =    FlaxBeitModelTester(self      )
       UpperCamelCase__         =    ConfigTester(self ,				config_class=snake_case_ ,				has_text_modality=snake_case_ ,				hidden_size=37      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       self.config_tester.run_common_tests()

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()

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

           UpperCamelCase__         =    ['pixel_values']
           self.assertListEqual(arg_names[:1] ,				snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           with self.subTest(model_class.__name__      ):
               UpperCamelCase__         =    self._prepare_for_class(snake_case_ ,				snake_case_      )
               UpperCamelCase__         =    model_class(snake_case_      )

               @jax.jit
               def model_jitted(snake_case_ ,				**snake_case_      ):
                   return model(pixel_values=snake_case_ ,				**snake_case_      )

               with self.subTest('JIT Enabled'      ):
                   UpperCamelCase__         =    model_jitted(**snake_case_      ).to_tuple()

               with self.subTest('JIT Disabled'      ):
                   with jax.disable_jit():
                       UpperCamelCase__         =    model_jitted(**snake_case_      ).to_tuple()

               self.assertEqual(len(snake_case_      ) ,				len(snake_case_      )      )
               for jitted_output, output in zip(snake_case_ ,				snake_case_      ):
                   self.assertEqual(jitted_output.shape ,				output.shape      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*snake_case_      )







   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       for model_class_name in self.all_model_classes:
           UpperCamelCase__         =    model_class_name.from_pretrained('microsoft/beit-base-patch16-224'      )
           UpperCamelCase__         =    model(np.ones((1, 3, 224, 224)      )      )
           self.assertIsNotNone(snake_case_      )







def   lowerCAmelCase_( )					->	Optional[int]:
    """simple docstring"""

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





@require_vision
@require_flax
class    __lowerCamelCase    (  unittest.TestCase  ):

   @cached_property
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       return BeitImageProcessor.from_pretrained('microsoft/beit-base-patch16-224'      ) if is_vision_available() else None

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__         =    FlaxBeitForMaskedImageModeling.from_pretrained('microsoft/beit-base-patch16-224-pt22k'      )

       UpperCamelCase__         =    self.default_image_processor
       UpperCamelCase__         =    prepare_img()
       UpperCamelCase__         =    image_processor(images=snake_case_ ,				return_tensors='np'      ).pixel_values

       # prepare bool_masked_pos
       UpperCamelCase__         =    np.ones((1, 196) ,				dtype=snake_case_      )

       # forward pass
       UpperCamelCase__         =    model(pixel_values=snake_case_ ,				bool_masked_pos=snake_case_      )
       UpperCamelCase__         =    outputs.logits

       # verify the logits
       UpperCamelCase__         =    (1, 196, 8192)
       self.assertEqual(logits.shape ,				snake_case_      )

       UpperCamelCase__         =    np.array(
           [[-3.2_437, 0.5_072, -13.9_174], [-3.2_456, 0.4_948, -13.9_401], [-3.2_033, 0.5_121, -13.8_550]]      )

       self.assertTrue(np.allclose(logits[bool_masked_pos][:3, :3] ,				snake_case_ ,				atol=1E-2      )      )

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    FlaxBeitForImageClassification.from_pretrained('microsoft/beit-base-patch16-224'      )

       UpperCamelCase__         =    self.default_image_processor
       UpperCamelCase__         =    prepare_img()
       UpperCamelCase__         =    image_processor(images=snake_case_ ,				return_tensors='np'      )

       # forward pass
       UpperCamelCase__         =    model(**snake_case_      )
       UpperCamelCase__         =    outputs.logits

       # verify the logits
       UpperCamelCase__         =    (1, 1000)
       self.assertEqual(logits.shape ,				snake_case_      )

       UpperCamelCase__         =    np.array([-1.2_385, -1.0_987, -1.0_108]      )

       self.assertTrue(np.allclose(logits[0, :3] ,				snake_case_ ,				atol=1E-4      )      )

       UpperCamelCase__         =    281
       self.assertEqual(logits.argmax(-1      ).item() ,				snake_case_      )







   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    FlaxBeitForImageClassification.from_pretrained('microsoft/beit-large-patch16-224-pt22k-ft22k'      )

       UpperCamelCase__         =    self.default_image_processor
       UpperCamelCase__         =    prepare_img()
       UpperCamelCase__         =    image_processor(images=snake_case_ ,				return_tensors='np'      )

       # forward pass
       UpperCamelCase__         =    model(**snake_case_      )
       UpperCamelCase__         =    outputs.logits

       # verify the logits
       UpperCamelCase__         =    (1, 2_1841)
       self.assertEqual(logits.shape ,				snake_case_      )

       UpperCamelCase__         =    np.array([1.6_881, -0.2_787, 0.5_901]      )

       self.assertTrue(np.allclose(logits[0, :3] ,				snake_case_ ,				atol=1E-4      )      )

       UpperCamelCase__         =    2396
       self.assertEqual(logits.argmax(-1      ).item() ,				snake_case_      )




