


'''simple docstring'''







from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow

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


if is_tf_available():
   import numpy as np
   import tensorflow as tf

   from transformers import (
       TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
       FlaubertConfig,
       TFFlaubertForMultipleChoice,
       TFFlaubertForQuestionAnsweringSimple,
       TFFlaubertForSequenceClassification,
       TFFlaubertForTokenClassification,
       TFFlaubertModel,
       TFFlaubertWithLMHeadModel,
   )







class A__       :






      def __init__( self			:int     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						)       ->					List[str]:




             '''simple docstring'''
             _a    : Any     					=parent
             _a    : Optional[int]     					=1_3
             _a    : Any     					=7
             _a    : List[str]     					=True
             _a    : Union[str, Any]     					=True
             _a    : Any     					=True
             _a    : Any     					=True
             _a    : int     					=True
             _a    : Tuple     					=False
             _a    : List[str]     					=False
             _a    : List[str]     					=False
             _a    : Tuple     					=2
             _a    : List[str]     					=9_9
             _a    : Dict     					=0
             _a    : Dict     					=3_2
             _a    : Optional[int]     					=2
             _a    : Optional[Any]     					=4
             _a    : Any     					=0.1
             _a    : str     					=0.1
             _a    : Union[str, Any]     					=5_1_2
             _a    : List[str]     					=1_6
             _a    : str     					=2
             _a    : Dict     					=0.02
             _a    : Dict     					=3
             _a    : str     					=4
             _a    : int     					="""last"""
             _a    : List[Any]     					=True
             _a    : Optional[int]     					=None
             _a    : Union[str, Any]     					=0






      def __UpperCAmelCase       ( self			:List[str]	)       ->					Any:




             '''simple docstring'''
             _a    : List[Any]     					=ids_tensor([self.batch_size, self.seq_length]     ,						self.vocab_size	)
             _a    : Tuple     					=random_attention_mask([self.batch_size, self.seq_length]     ,						dtype=tf.floataa	)

             _a    : Union[str, Any]     					=None
             if self.use_input_lengths:
                    _a    : List[str]     					=(
                        ids_tensor([self.batch_size]     ,						vocab_size=2	) + self.seq_length - 2
                    )  # small variation of seq_length

             _a    : str     					=None
             if self.use_token_type_ids:
                    _a    : List[str]     					=ids_tensor([self.batch_size, self.seq_length]     ,						self.n_langs	)

             _a    : int     					=None
             _a    : Optional[Any]     					=None
             _a    : Tuple     					=None
             if self.use_labels:
                    _a    : Optional[int]     					=ids_tensor([self.batch_size]     ,						self.type_sequence_label_size	)
                    _a    : Dict     					=ids_tensor([self.batch_size, self.seq_length]     ,						self.num_labels	)
                    _a    : Tuple     					=ids_tensor([self.batch_size]     ,						2     ,						dtype=tf.floataa	)
                    _a    : List[Any]     					=ids_tensor([self.batch_size]     ,						self.num_choices	)

             _a    : List[str]     					=FlaubertConfig(
                 vocab_size=self.vocab_size     ,						n_special=self.n_special     ,						emb_dim=self.hidden_size     ,						n_layers=self.num_hidden_layers     ,						n_heads=self.num_attention_heads     ,						dropout=self.hidden_dropout_prob     ,						attention_dropout=self.attention_probs_dropout_prob     ,						gelu_activation=self.gelu_activation     ,						sinusoidal_embeddings=self.sinusoidal_embeddings     ,						asm=self.asm     ,						causal=self.causal     ,						n_langs=self.n_langs     ,						max_position_embeddings=self.max_position_embeddings     ,						initializer_range=self.initializer_range     ,						summary_type=self.summary_type     ,						use_proj=self.use_proj     ,						bos_token_id=self.bos_token_id     ,						)

             return (
                 config,
                 input_ids,
                 token_type_ids,
                 input_lengths,
                 sequence_labels,
                 token_labels,
                 is_impossible_labels,
                 choice_labels,
                 input_mask,
             )






      def __UpperCAmelCase       ( self			:Any     ,						SCREAMING_SNAKE_CASE			:Tuple     ,						SCREAMING_SNAKE_CASE			:Optional[int]     ,						SCREAMING_SNAKE_CASE			:Tuple     ,						SCREAMING_SNAKE_CASE			:Tuple     ,						SCREAMING_SNAKE_CASE			:Optional[Any]     ,						SCREAMING_SNAKE_CASE			:List[Any]     ,						SCREAMING_SNAKE_CASE			:int     ,						SCREAMING_SNAKE_CASE			:Optional[Any]     ,						SCREAMING_SNAKE_CASE			:Any     ,						)       ->					Union[str, Any]:




             '''simple docstring'''
             _a    : Optional[Any]     					=TFFlaubertModel(config=SCREAMING_SNAKE_CASE	)
             _a    : List[str]     					={"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
             _a    : List[str]     					=model(SCREAMING_SNAKE_CASE	)

             _a    : List[str]     					=[input_ids, input_mask]
             _a    : int     					=model(SCREAMING_SNAKE_CASE	)
             self.parent.assertEqual(result.last_hidden_state.shape     ,						(self.batch_size, self.seq_length, self.hidden_size)	)






      def __UpperCAmelCase       ( self			:Any     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:Any     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:Optional[Any]     ,						SCREAMING_SNAKE_CASE			:Dict     ,						SCREAMING_SNAKE_CASE			:int     ,						SCREAMING_SNAKE_CASE			:Any     ,						SCREAMING_SNAKE_CASE			:Dict     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						)       ->					List[Any]:




             '''simple docstring'''
             _a    : int     					=TFFlaubertWithLMHeadModel(SCREAMING_SNAKE_CASE	)

             _a    : Optional[int]     					={"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
             _a    : Dict     					=model(SCREAMING_SNAKE_CASE	)

             self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.vocab_size)	)






      def __UpperCAmelCase       ( self			:List[Any]     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:List[str]     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:int     ,						SCREAMING_SNAKE_CASE			:List[Any]     ,						SCREAMING_SNAKE_CASE			:Any     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:int     ,						SCREAMING_SNAKE_CASE			:List[Any]     ,						)       ->					Any:




             '''simple docstring'''
             _a    : Union[str, Any]     					=TFFlaubertForQuestionAnsweringSimple(SCREAMING_SNAKE_CASE	)

             _a    : Union[str, Any]     					={"""input_ids""": input_ids, """lengths""": input_lengths}

             _a    : Optional[int]     					=model(SCREAMING_SNAKE_CASE	)

             self.parent.assertEqual(result.start_logits.shape     ,						(self.batch_size, self.seq_length)	)
             self.parent.assertEqual(result.end_logits.shape     ,						(self.batch_size, self.seq_length)	)






      def __UpperCAmelCase       ( self			:List[Any]     ,						SCREAMING_SNAKE_CASE			:List[Any]     ,						SCREAMING_SNAKE_CASE			:int     ,						SCREAMING_SNAKE_CASE			:Dict     ,						SCREAMING_SNAKE_CASE			:Tuple     ,						SCREAMING_SNAKE_CASE			:Dict     ,						SCREAMING_SNAKE_CASE			:List[str]     ,						SCREAMING_SNAKE_CASE			:Tuple     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:List[Any]     ,						)       ->					str:




             '''simple docstring'''
             _a    : int     					=TFFlaubertForSequenceClassification(SCREAMING_SNAKE_CASE	)

             _a    : List[str]     					={"""input_ids""": input_ids, """lengths""": input_lengths}

             _a    : Any     					=model(SCREAMING_SNAKE_CASE	)

             self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.type_sequence_label_size)	)






      def __UpperCAmelCase       ( self			:str     ,						SCREAMING_SNAKE_CASE			:Tuple     ,						SCREAMING_SNAKE_CASE			:Tuple     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:Optional[int]     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:List[Any]     ,						SCREAMING_SNAKE_CASE			:Tuple     ,						SCREAMING_SNAKE_CASE			:List[Any]     ,						SCREAMING_SNAKE_CASE			:str     ,						)       ->					Any:




             '''simple docstring'''
             _a    : Any     					=self.num_labels
             _a    : List[Any]     					=TFFlaubertForTokenClassification(config=SCREAMING_SNAKE_CASE	)
             _a    : List[str]     					={"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             _a    : Optional[int]     					=model(SCREAMING_SNAKE_CASE	)
             self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.num_labels)	)






      def __UpperCAmelCase       ( self			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:List[Any]     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:Optional[Any]     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:Optional[Any]     ,						SCREAMING_SNAKE_CASE			:int     ,						SCREAMING_SNAKE_CASE			:Dict     ,						)       ->					Dict:




             '''simple docstring'''
             _a    : int     					=self.num_choices
             _a    : Optional[Any]     					=TFFlaubertForMultipleChoice(config=SCREAMING_SNAKE_CASE	)
             _a    : Tuple     					=tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE     ,						1	)     ,						(1, self.num_choices, 1)	)
             _a    : List[str]     					=tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE     ,						1	)     ,						(1, self.num_choices, 1)	)
             _a    : Optional[Any]     					=tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE     ,						1	)     ,						(1, self.num_choices, 1)	)
             _a    : Tuple     					={
                 """input_ids""": multiple_choice_inputs_ids,
                 """attention_mask""": multiple_choice_input_mask,
                 """token_type_ids""": multiple_choice_token_type_ids,
             }
             _a    : Optional[Any]     					=model(SCREAMING_SNAKE_CASE	)
             self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.num_choices)	)






      def __UpperCAmelCase       ( self			:Optional[int]	)       ->					Dict:




             '''simple docstring'''
             _a    : List[Any]     					=self.prepare_config_and_inputs()
             (
                 (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    
             )    : Tuple     					=config_and_inputs
             _a    : Dict     					={
                 """input_ids""": input_ids,
                 """token_type_ids""": token_type_ids,
                 """langs""": token_type_ids,
                 """lengths""": input_lengths,
             }
             return config, inputs_dict







@require_tf
class A__       (						UpperCAmelCase__ ,     UpperCAmelCase__ ,     unittest.TestCase      ):
      __UpperCamelCase       :  Union[str, Any]	       =							(
          (
              TFFlaubertModel,
              TFFlaubertWithLMHeadModel,
              TFFlaubertForSequenceClassification,
              TFFlaubertForQuestionAnsweringSimple,
              TFFlaubertForTokenClassification,
              TFFlaubertForMultipleChoice,
          )
          if is_tf_available()
          else ()
      )
      __UpperCamelCase       :  str	       =							(
          (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
      )  # TODO (PVP): Check other models whether language generation is also applicable
      __UpperCamelCase       :  Optional[int]	       =							(
          {
              "feature-extraction": TFFlaubertModel,
              "fill-mask": TFFlaubertWithLMHeadModel,
              "question-answering": TFFlaubertForQuestionAnsweringSimple,
              "text-classification": TFFlaubertForSequenceClassification,
              "token-classification": TFFlaubertForTokenClassification,
              "zero-shot": TFFlaubertForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      __UpperCamelCase       :  Tuple	       =							False
      __UpperCamelCase       :  List[Any]	       =							False






      def __UpperCAmelCase       ( self			:Tuple     ,						SCREAMING_SNAKE_CASE			:int     ,						SCREAMING_SNAKE_CASE			:Optional[Any]     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:Any	)       ->					Union[str, Any]:




             '''simple docstring'''
             if (
                 pipeline_test_casse_name == "QAPipelineTests"
                 and tokenizer_name is not None
                 and not tokenizer_name.endswith("""Fast"""	)
             ):
                    # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
                    # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
                    # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
                    return True

             return False






      def __UpperCAmelCase       ( self			:int	)       ->					Any:




             '''simple docstring'''
             _a    : Optional[int]     					=TFFlaubertModelTester(self	)
             _a    : List[str]     					=ConfigTester(self     ,						config_class=SCREAMING_SNAKE_CASE     ,						emb_dim=3_7	)






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




             '''simple docstring'''
             self.config_tester.run_common_tests()






      def __UpperCAmelCase       ( self			:str	)       ->					Optional[Any]:




             '''simple docstring'''
             _a    : str     					=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_flaubert_model(*SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:List[str]	)       ->					List[str]:




             '''simple docstring'''
             _a    : Tuple     					=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_flaubert_lm_head(*SCREAMING_SNAKE_CASE	)






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




             '''simple docstring'''
             _a    : Dict     					=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_flaubert_qa(*SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:Optional[Any]	)       ->					Any:




             '''simple docstring'''
             _a    : int     					=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_flaubert_sequence_classif(*SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:str	)       ->					Dict:




             '''simple docstring'''
             _a    : Tuple     					=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_flaubert_for_token_classification(*SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:str	)       ->					Optional[int]:




             '''simple docstring'''
             _a    : str     					=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_flaubert_for_multiple_choice(*SCREAMING_SNAKE_CASE	)






      @slow
      def __UpperCAmelCase       ( self			:Tuple	)       ->					str:




             '''simple docstring'''
             for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    _a    : Any     					=TFFlaubertModel.from_pretrained(SCREAMING_SNAKE_CASE	)
                    self.assertIsNotNone(SCREAMING_SNAKE_CASE	)







@require_tf
@require_sentencepiece
@require_tokenizers
class A__       (						unittest.TestCase      ):






      @slow
      def __UpperCAmelCase       ( self			:int	)       ->					List[Any]:




             '''simple docstring'''
             _a    : List[str]     					=TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased"""	)

             _a    : List[Any]     					=tf.convert_to_tensor(
                 [[0, 1_5_8, 7_3_5, 2_5_9_2, 1_4_2_4, 6_7_2_7, 8_2, 1]]     ,						dtype=tf.intaa     ,						)  # "J'aime flaubert !"

             _a    : Optional[Any]     					=model(SCREAMING_SNAKE_CASE	)[0]
             _a    : List[str]     					=tf.TensorShape((1, 8, 5_1_2)	)
             self.assertEqual(output.shape     ,						SCREAMING_SNAKE_CASE	)
             # compare the actual values for a slice.
             _a    : List[str]     					=tf.convert_to_tensor(
                 [
                     [
                         [-1.8_768_773, -1.566_555, 0.27_072_418],
                         [-1.6_920_038, -0.5_873_505, 1.9_329_599],
                         [-2.9_563_985, -1.6_993_835, 1.7_972_052],
                     ]
                 ]     ,						dtype=tf.floataa     ,						)

             self.assertTrue(np.allclose(output[:, :3, :3].numpy()     ,						expected_slice.numpy()     ,						atol=1e-4	)	)






'''simple docstring'''







from ...configuration_utils import PretrainedConfig
from ...utils import logging


A__:    Dict					    =       logging.get_logger(__name__)

A__:    Tuple					    =       {
    '''weiweishi/roc-bert-base-zh''': '''https://huggingface.co/weiweishi/roc-bert-base-zh/resolve/main/config.json''',
}







class A__       (						UpperCAmelCase__      ):
      __UpperCamelCase       :  Tuple	       =							"roc_bert"






      def __init__( self			:Optional[int]     ,						SCREAMING_SNAKE_CASE			:Tuple=3_0_5_2_2     ,						SCREAMING_SNAKE_CASE			:List[str]=7_6_8     ,						SCREAMING_SNAKE_CASE			:Dict=1_2     ,						SCREAMING_SNAKE_CASE			:List[str]=1_2     ,						SCREAMING_SNAKE_CASE			:Tuple=3_0_7_2     ,						SCREAMING_SNAKE_CASE			:List[Any]="gelu"     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]=0.1     ,						SCREAMING_SNAKE_CASE			:List[Any]=0.1     ,						SCREAMING_SNAKE_CASE			:int=5_1_2     ,						SCREAMING_SNAKE_CASE			:Optional[Any]=2     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]=0.02     ,						SCREAMING_SNAKE_CASE			:Optional[Any]=1e-12     ,						SCREAMING_SNAKE_CASE			:Any=True     ,						SCREAMING_SNAKE_CASE			:List[Any]=0     ,						SCREAMING_SNAKE_CASE			:Optional[int]="absolute"     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]=None     ,						SCREAMING_SNAKE_CASE			:List[Any]=True     ,						SCREAMING_SNAKE_CASE			:int=True     ,						SCREAMING_SNAKE_CASE			:Optional[int]=7_6_8     ,						SCREAMING_SNAKE_CASE			:Optional[Any]=9_1_0     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]=5_1_2     ,						SCREAMING_SNAKE_CASE			:str=2_4_8_5_8     ,						SCREAMING_SNAKE_CASE			:List[Any]=True     ,						**SCREAMING_SNAKE_CASE			:Tuple     ,						)       ->					Optional[int]:




             '''simple docstring'''
             _a    : List[str]     					=vocab_size
             _a    : List[str]     					=max_position_embeddings
             _a    : Optional[Any]     					=hidden_size
             _a    : List[Any]     					=num_hidden_layers
             _a    : List[str]     					=num_attention_heads
             _a    : int     					=intermediate_size
             _a    : Any     					=hidden_act
             _a    : Dict     					=hidden_dropout_prob
             _a    : int     					=attention_probs_dropout_prob
             _a    : str     					=initializer_range
             _a    : Optional[int]     					=type_vocab_size
             _a    : Any     					=layer_norm_eps
             _a    : Any     					=use_cache
             _a    : Optional[int]     					=enable_pronunciation
             _a    : Optional[Any]     					=enable_shape
             _a    : Optional[Any]     					=pronunciation_embed_dim
             _a    : Tuple     					=pronunciation_vocab_size
             _a    : Union[str, Any]     					=shape_embed_dim
             _a    : Any     					=shape_vocab_size
             _a    : Tuple     					=concat_input
             _a    : List[str]     					=position_embedding_type
             _a    : List[str]     					=classifier_dropout
             super().__init__(pad_token_id=SCREAMING_SNAKE_CASE     ,						**SCREAMING_SNAKE_CASE	)


