



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     _UpperCAmelCase			:




					def __init__(				self ,						a__ ,						):
									A__		 =					parent
									A__		 =					1_3
									A__		 =					7
									A__		 =					True
									A__		 =					True
									A__		 =					True
									A__		 =					True
									A__		 =					True
									A__		 =					False
									A__		 =					False
									A__		 =					False
									A__		 =					2
									A__		 =					9_9
									A__		 =					0
									A__		 =					3_2
									A__		 =					2
									A__		 =					4
									A__		 =					0.1
									A__		 =					0.1
									A__		 =					5_1_2
									A__		 =					1_6
									A__		 =					2
									A__		 =					0.0_2
									A__		 =					3
									A__		 =					4
									A__		 =					'''last'''
									A__		 =					True
									A__		 =					None
									A__		 =					0




					def 		snake_case_		(				self):
									A__		 =					ids_tensor([self.batch_size, self.seq_length] ,						self.vocab_size)
									A__		 =					random_attention_mask([self.batch_size, self.seq_length] ,						dtype=tf.floataa)

									A__		 =					None
									if self.use_input_lengths:
													A__		 =					(
													    ids_tensor([self.batch_size] ,						vocab_size=2) + self.seq_length - 2
													)  # small variation of seq_length

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

									A__		 =					None
									A__		 =					None
									A__		 =					None
									if self.use_labels:
													A__		 =					ids_tensor([self.batch_size] ,						self.type_sequence_label_size)
													A__		 =					ids_tensor([self.batch_size, self.seq_length] ,						self.num_labels)
													A__		 =					ids_tensor([self.batch_size] ,						2 ,						dtype=tf.floataa)
													A__		 =					ids_tensor([self.batch_size] ,						self.num_choices)

									A__		 =					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 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
									A__		 =					TFFlaubertModel(config=a__)
									A__		 =					{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
									A__		 =					model(a__)

									A__		 =					[input_ids, input_mask]
									A__		 =					model(a__)
									self.parent.assertEqual(result.last_hidden_state.shape ,						(self.batch_size, self.seq_length, self.hidden_size))




					def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
									A__		 =					TFFlaubertWithLMHeadModel(a__)

									A__		 =					{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
									A__		 =					model(a__)

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




					def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
									A__		 =					TFFlaubertForQuestionAnsweringSimple(a__)

									A__		 =					{'''input_ids''': input_ids, '''lengths''': input_lengths}

									A__		 =					model(a__)

									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 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
									A__		 =					TFFlaubertForSequenceClassification(a__)

									A__		 =					{'''input_ids''': input_ids, '''lengths''': input_lengths}

									A__		 =					model(a__)

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




					def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
									A__		 =					self.num_labels
									A__		 =					TFFlaubertForTokenClassification(config=a__)
									A__		 =					{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
									A__		 =					model(a__)
									self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.num_labels))




					def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
									A__		 =					self.num_choices
									A__		 =					TFFlaubertForMultipleChoice(config=a__)
									A__		 =					tf.tile(tf.expand_dims(a__ ,						1) ,						(1, self.num_choices, 1))
									A__		 =					tf.tile(tf.expand_dims(a__ ,						1) ,						(1, self.num_choices, 1))
									A__		 =					tf.tile(tf.expand_dims(a__ ,						1) ,						(1, self.num_choices, 1))
									A__		 =					{
									    '''input_ids''': multiple_choice_inputs_ids,
									    '''attention_mask''': multiple_choice_input_mask,
									    '''token_type_ids''': multiple_choice_token_type_ids,
									}
									A__		 =					model(a__)
									self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.num_choices))




					def 		snake_case_		(				self):
									A__		 =					self.prepare_config_and_inputs()
									(
									    (
									    A__	
									) ,	(
									    A__	
									) ,	(
									    A__	
									) ,	(
									    A__	
									) ,	(
									    A__	
									) ,	(
									    A__	
									) ,	(
									    A__	
									) ,	(
									    A__	
									) ,	(
									    A__	
									) ,		
									)		 =					config_and_inputs
									A__		 =					{
									    '''input_ids''': input_ids,
									    '''token_type_ids''': token_type_ids,
									    '''langs''': token_type_ids,
									    '''lengths''': input_lengths,
									}
									return config, inputs_dict







@require_tf
class     _UpperCAmelCase			(       A__			,      A__			,      unittest.TestCase     ):
					UpperCamelCase__		    =				(
					    (
					        TFFlaubertModel,
					        TFFlaubertWithLMHeadModel,
					        TFFlaubertForSequenceClassification,
					        TFFlaubertForQuestionAnsweringSimple,
					        TFFlaubertForTokenClassification,
					        TFFlaubertForMultipleChoice,
					    )
					    if is_tf_available()
					    else ()
					)
					UpperCamelCase__		    =				(
					    (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
					)  # TODO (PVP): Check other models whether language generation is also applicable
					UpperCamelCase__		    =				(
					    {
					        '''feature-extraction''': TFFlaubertModel,
					        '''fill-mask''': TFFlaubertWithLMHeadModel,
					        '''question-answering''': TFFlaubertForQuestionAnsweringSimple,
					        '''text-classification''': TFFlaubertForSequenceClassification,
					        '''token-classification''': TFFlaubertForTokenClassification,
					        '''zero-shot''': TFFlaubertForSequenceClassification,
					    }
					    if is_tf_available()
					    else {}
					)
					UpperCamelCase__		    =				False
					UpperCamelCase__		    =				False




					def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__):
									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 		snake_case_		(				self):
									A__		 =					TFFlaubertModelTester(self)
									A__		 =					ConfigTester(self ,						config_class=a__ ,						emb_dim=3_7)




					def 		snake_case_		(				self):
									self.config_tester.run_common_tests()




					def 		snake_case_		(				self):
									A__		 =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_model(*a__)




					def 		snake_case_		(				self):
									A__		 =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_lm_head(*a__)




					def 		snake_case_		(				self):
									A__		 =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_qa(*a__)




					def 		snake_case_		(				self):
									A__		 =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_sequence_classif(*a__)




					def 		snake_case_		(				self):
									A__		 =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_for_token_classification(*a__)




					def 		snake_case_		(				self):
									A__		 =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_for_multiple_choice(*a__)




					@slow
					def 		snake_case_		(				self):
									for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													A__		 =					TFFlaubertModel.from_pretrained(a__)
													self.assertIsNotNone(a__)







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




					@slow
					def 		snake_case_		(				self):
									A__		 =					TFFlaubertModel.from_pretrained('''jplu/tf-flaubert-small-cased''')

									A__		 =					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__		 =					model(a__)[0]
									A__		 =					tf.TensorShape((1, 8, 5_1_2))
									self.assertEqual(output.shape ,						a__)
									# compare the actual values for a slice.
									A__		 =					tf.convert_to_tensor(
									    [
									        [
									            [-1.8_7_6_8_7_7_3, -1.5_6_6_5_5_5, 0.2_7_0_7_2_4_1_8],
									            [-1.6_9_2_0_0_3_8, -0.5_8_7_3_5_0_5, 1.9_3_2_9_5_9_9],
									            [-2.9_5_6_3_9_8_5, -1.6_9_9_3_8_3_5, 1.7_9_7_2_0_5_2],
									        ]
									    ] ,						dtype=tf.floataa ,						)

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





import numpy as np



def 		lowerCAmelCase__    (					UpperCamelCase_				:       np.array	)->  np.array:
    return 1 / (1 + np.exp(-vector	))



def 		lowerCAmelCase__    (					UpperCamelCase_				:       np.array	)->  np.array:
    return vector * sigmoid(1.702 * vector	)


if __name__ == "__main__":
   import doctest

   doctest.testmod()
