"""simple docstring"""


import unittest

import numpy as np

from transformers import AlbertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
 import jax.numpy as jnp

 from transformers.models.albert.modeling_flax_albert import (
     FlaxAlbertForMaskedLM,
     FlaxAlbertForMultipleChoice,
     FlaxAlbertForPreTraining,
     FlaxAlbertForQuestionAnswering,
     FlaxAlbertForSequenceClassification,
     FlaxAlbertForTokenClassification,
     FlaxAlbertModel,
 )






class    a__    (   unittest.TestCase	):


   def __init__(     self,				_UpperCAmelCase,				_UpperCAmelCase=13,				_UpperCAmelCase=7,				_UpperCAmelCase=True,				_UpperCAmelCase=True,				_UpperCAmelCase=True,				_UpperCAmelCase=True,				_UpperCAmelCase=99,				_UpperCAmelCase=32,				_UpperCAmelCase=5,				_UpperCAmelCase=4,				_UpperCAmelCase=37,				_UpperCAmelCase="gelu",				_UpperCAmelCase=0.1,				_UpperCAmelCase=0.1,				_UpperCAmelCase=512,				_UpperCAmelCase=16,				_UpperCAmelCase=2,				_UpperCAmelCase=0.02,				_UpperCAmelCase=4,				):
        '''simple docstring'''



        lowercase__				 =							parent
        lowercase__				 =							batch_size
        lowercase__				 =							seq_length
        lowercase__				 =							is_training
        lowercase__				 =							use_attention_mask
        lowercase__				 =							use_token_type_ids
        lowercase__				 =							use_labels
        lowercase__				 =							vocab_size
        lowercase__				 =							hidden_size
        lowercase__				 =							num_hidden_layers
        lowercase__				 =							num_attention_heads
        lowercase__				 =							intermediate_size
        lowercase__				 =							hidden_act
        lowercase__				 =							hidden_dropout_prob
        lowercase__				 =							attention_probs_dropout_prob
        lowercase__				 =							max_position_embeddings
        lowercase__				 =							type_vocab_size
        lowercase__				 =							type_sequence_label_size
        lowercase__				 =							initializer_range
        lowercase__				 =							num_choices


   def 	snake_case__	(     self  ):
        '''simple docstring'''



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

        lowercase__				 =							None
        if self.use_attention_mask:
             lowercase__				 =							random_attention_mask([self.batch_size, self.seq_length]  )

        lowercase__				 =							None
        if self.use_token_type_ids:
             lowercase__				 =							ids_tensor([self.batch_size, self.seq_length],				self.type_vocab_size  )

        lowercase__				 =							AlbertConfig(
            vocab_size=self.vocab_size,				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,				max_position_embeddings=self.max_position_embeddings,				type_vocab_size=self.type_vocab_size,				is_decoder=_UpperCAmelCase,				initializer_range=self.initializer_range,				)

        return config, input_ids, token_type_ids, attention_mask


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.prepare_config_and_inputs()
        lowercase__ ,						lowercase__ ,						lowercase__ ,						lowercase__				 =							config_and_inputs
        lowercase__				 =							{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": attention_mask}
        return config, inputs_dict






@require_flax
class    a__    (   _a					,					unittest.TestCase	):
   snake_case_							=      (
       (
           FlaxAlbertModel,
           FlaxAlbertForPreTraining,
           FlaxAlbertForMaskedLM,
           FlaxAlbertForMultipleChoice,
           FlaxAlbertForQuestionAnswering,
           FlaxAlbertForSequenceClassification,
           FlaxAlbertForTokenClassification,
           FlaxAlbertForQuestionAnswering,
       )
       if is_flax_available()
       else ()
   )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							FlaxAlbertModelTester(self  )


   @slow
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        for model_class_name in self.all_model_classes:
             lowercase__				 =							model_class_name.from_pretrained("albert-base-v2"  )
             lowercase__				 =							model(np.ones((1, 1)  )  )
             self.assertIsNotNone(_UpperCAmelCase  )






@require_flax
class    a__    (   unittest.TestCase	):


   @slow
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							FlaxAlbertModel.from_pretrained("albert-base-v2"  )
        lowercase__				 =							np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]  )
        lowercase__				 =							np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
        lowercase__				 =							model(_UpperCAmelCase,				attention_mask=_UpperCAmelCase  )[0]
        lowercase__				 =							(1, 11, 768)
        self.assertEqual(output.shape,				_UpperCAmelCase  )
        lowercase__				 =							np.array(
            [[[-0.6_513, 1.5_035, -0.2_766], [-0.6_515, 1.5_046, -0.2_780], [-0.6_512, 1.5_049, -0.2_784]]]  )

        self.assertTrue(jnp.allclose(output[:, 1:4, 1:4],				_UpperCAmelCase,				atol=1E-4  )  )





"""simple docstring"""


import unittest

from transformers import AutoConfig, AutoTokenizer, BertConfig, TensorType, is_flax_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, slow


if is_flax_available():
 import jax

 from transformers.models.auto.modeling_flax_auto import FlaxAutoModel
 from transformers.models.bert.modeling_flax_bert import FlaxBertModel
 from transformers.models.roberta.modeling_flax_roberta import FlaxRobertaModel






@require_flax
class    a__    (   unittest.TestCase	):


   @slow
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        for model_name in ["bert-base-cased", "bert-large-uncased"]:
             with self.subTest(_UpperCAmelCase  ):
                  lowercase__				 =							AutoConfig.from_pretrained(_UpperCAmelCase  )
                  self.assertIsNotNone(_UpperCAmelCase  )
                  self.assertIsInstance(_UpperCAmelCase,				_UpperCAmelCase  )

                  lowercase__				 =							FlaxAutoModel.from_pretrained(_UpperCAmelCase  )
                  self.assertIsNotNone(_UpperCAmelCase  )
                  self.assertIsInstance(_UpperCAmelCase,				_UpperCAmelCase  )


   @slow
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        for model_name in ["roberta-base", "roberta-large"]:
             with self.subTest(_UpperCAmelCase  ):
                  lowercase__				 =							AutoConfig.from_pretrained(_UpperCAmelCase  )
                  self.assertIsNotNone(_UpperCAmelCase  )
                  self.assertIsInstance(_UpperCAmelCase,				_UpperCAmelCase  )

                  lowercase__				 =							FlaxAutoModel.from_pretrained(_UpperCAmelCase  )
                  self.assertIsNotNone(_UpperCAmelCase  )
                  self.assertIsInstance(_UpperCAmelCase,				_UpperCAmelCase  )


   @slow
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        for model_name in ["bert-base-cased", "bert-large-uncased"]:
             lowercase__				 =							AutoTokenizer.from_pretrained(_UpperCAmelCase  )
             lowercase__				 =							FlaxBertModel.from_pretrained(_UpperCAmelCase  )
             lowercase__				 =							tokenizer("Do you support jax jitted function?",				return_tensors=TensorType.JAX  )

             @jax.jit
             def eval(**_UpperCAmelCase  ):
                  return model(**_UpperCAmelCase  )

             eval(**_UpperCAmelCase  ).block_until_ready()


   @slow
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        for model_name in ["roberta-base", "roberta-large"]:
             lowercase__				 =							AutoTokenizer.from_pretrained(_UpperCAmelCase  )
             lowercase__				 =							FlaxRobertaModel.from_pretrained(_UpperCAmelCase  )
             lowercase__				 =							tokenizer("Do you support jax jitted function?",				return_tensors=TensorType.JAX  )

             @jax.jit
             def eval(**_UpperCAmelCase  ):
                  return model(**_UpperCAmelCase  )

             eval(**_UpperCAmelCase  ).block_until_ready()


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        with self.assertRaisesRegex(
            _UpperCAmelCase,				"bert-base is not a local folder and is not a valid model identifier"  ):
             lowercase__				 =							FlaxAutoModel.from_pretrained("bert-base"  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        with self.assertRaisesRegex(
            _UpperCAmelCase,				R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"  ):
             lowercase__				 =							FlaxAutoModel.from_pretrained(_UpperCAmelCase,				revision="aaaaaa"  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        with self.assertRaisesRegex(
            _UpperCAmelCase,				"hf-internal-testing/config-no-model does not appear to have a file named flax_model.msgpack",				):
             lowercase__				 =							FlaxAutoModel.from_pretrained("hf-internal-testing/config-no-model"  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        with self.assertRaisesRegex(_UpperCAmelCase,				"Use `from_pt=True` to load this model"  ):
             lowercase__				 =							FlaxAutoModel.from_pretrained("hf-internal-testing/tiny-bert-pt-only"  )




