




'''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     :  str       ,		__lowerCAmelCase     :  Optional[Any]       ,		):
							__snake_case						 =   parent
							__snake_case						 =   1_3
							__snake_case						 =   7
							__snake_case						 =   True
							__snake_case						 =   True
							__snake_case						 =   True
							__snake_case						 =   True
							__snake_case						 =   True
							__snake_case						 =   False
							__snake_case						 =   False
							__snake_case						 =   False
							__snake_case						 =   2
							__snake_case						 =   9_9
							__snake_case						 =   0
							__snake_case						 =   3_2
							__snake_case						 =   2
							__snake_case						 =   4
							__snake_case						 =   0.1
							__snake_case						 =   0.1
							__snake_case						 =   5_1_2
							__snake_case						 =   1_6
							__snake_case						 =   2
							__snake_case						 =   0.02
							__snake_case						 =   3
							__snake_case						 =   4
							__snake_case						 =   'last'
							__snake_case						 =   True
							__snake_case						 =   None
							__snake_case						 =   0




	def   lowercase__   (       self     :  Dict      ):
							__snake_case						 =   ids_tensor([self.batch_size, self.seq_length]       ,		self.vocab_size      )
							__snake_case						 =   random_attention_mask([self.batch_size, self.seq_length]       ,		dtype=tf.floataa      )

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

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

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

							__snake_case						 =   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   lowercase__   (       self     :  Optional[Any]       ,		__lowerCAmelCase     :  Optional[int]       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  List[Any]       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  Optional[Any]       ,		__lowerCAmelCase     :  List[str]       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  Optional[int]       ,		):
							__snake_case						 =   TFFlaubertModel(config=__lowerCAmelCase      )
							__snake_case						 =   {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
							__snake_case						 =   model(__lowerCAmelCase      )

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




	def   lowercase__   (       self     :  List[Any]       ,		__lowerCAmelCase     :  Tuple       ,		__lowerCAmelCase     :  Dict       ,		__lowerCAmelCase     :  List[Any]       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  Optional[Any]       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  List[Any]       ,		__lowerCAmelCase     :  List[Any]       ,		__lowerCAmelCase     :  List[Any]       ,		):
							__snake_case						 =   TFFlaubertWithLMHeadModel(__lowerCAmelCase      )

							__snake_case						 =   {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
							__snake_case						 =   model(__lowerCAmelCase      )

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




	def   lowercase__   (       self     :  int       ,		__lowerCAmelCase     :  Dict       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  Any       ,		__lowerCAmelCase     :  Tuple       ,		__lowerCAmelCase     :  Optional[Any]       ,		__lowerCAmelCase     :  List[Any]       ,		__lowerCAmelCase     :  Optional[Any]       ,		__lowerCAmelCase     :  Optional[int]       ,		__lowerCAmelCase     :  str       ,		):
							__snake_case						 =   TFFlaubertForQuestionAnsweringSimple(__lowerCAmelCase      )

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

							__snake_case						 =   model(__lowerCAmelCase      )

							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   lowercase__   (       self     :  Union[str, Any]       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  Dict       ,		__lowerCAmelCase     :  List[str]       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  Any       ,		__lowerCAmelCase     :  Tuple       ,		__lowerCAmelCase     :  List[Any]       ,		__lowerCAmelCase     :  Dict       ,		):
							__snake_case						 =   TFFlaubertForSequenceClassification(__lowerCAmelCase      )

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

							__snake_case						 =   model(__lowerCAmelCase      )

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




	def   lowercase__   (       self     :  Optional[int]       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  List[str]       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  Optional[int]       ,		__lowerCAmelCase     :  Optional[Any]       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  Optional[int]       ,		):
							__snake_case						 =   self.num_labels
							__snake_case						 =   TFFlaubertForTokenClassification(config=__lowerCAmelCase      )
							__snake_case						 =   {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
							__snake_case						 =   model(__lowerCAmelCase      )
							self.parent.assertEqual(result.logits.shape       ,		(self.batch_size, self.seq_length, self.num_labels)      )




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




	def   lowercase__   (       self     :  Optional[int]      ):
							__snake_case						 =   self.prepare_config_and_inputs()
							(
							    (
							    __snake_case
							) ,       (
							    __snake_case
							) ,       (
							    __snake_case
							) ,       (
							    __snake_case
							) ,       (
							    __snake_case
							) ,       (
							    __snake_case
							) ,       (
							    __snake_case
							) ,       (
							    __snake_case
							) ,       (
							    __snake_case
							) ,       
							)						 =   config_and_inputs
							__snake_case						 =   {
							    '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						):
	lowercase_       :     int			  =      (
	    (
	        TFFlaubertModel,
	        TFFlaubertWithLMHeadModel,
	        TFFlaubertForSequenceClassification,
	        TFFlaubertForQuestionAnsweringSimple,
	        TFFlaubertForTokenClassification,
	        TFFlaubertForMultipleChoice,
	    )
	    if is_tf_available()
	    else ()
	)
	lowercase_       :     Optional[int]			  =      (
	    (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
	)  # TODO (PVP): Check other models whether language generation is also applicable
	lowercase_       :     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 {}
	)
	lowercase_       :     str			  =      False
	lowercase_       :     List[str]			  =      False




	def   lowercase__   (       self     :  Optional[int]       ,		__lowerCAmelCase     :  List[str]       ,		__lowerCAmelCase     :  List[Any]       ,		__lowerCAmelCase     :  Any       ,		__lowerCAmelCase     :  Optional[int]       ,		__lowerCAmelCase     :  Any      ):
							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   lowercase__   (       self     :  Optional[Any]      ):
							__snake_case						 =   TFFlaubertModelTester(self      )
							__snake_case						 =   ConfigTester(self       ,		config_class=__lowerCAmelCase       ,		emb_dim=3_7      )




	def   lowercase__   (       self     :  Union[str, Any]      ):
							self.config_tester.run_common_tests()




	def   lowercase__   (       self     :  int      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_model(*__lowerCAmelCase      )




	def   lowercase__   (       self     :  Any      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_lm_head(*__lowerCAmelCase      )




	def   lowercase__   (       self     :  Dict      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_qa(*__lowerCAmelCase      )




	def   lowercase__   (       self     :  List[Any]      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_sequence_classif(*__lowerCAmelCase      )




	def   lowercase__   (       self     :  List[Any]      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_for_token_classification(*__lowerCAmelCase      )




	def   lowercase__   (       self     :  List[Any]      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_flaubert_for_multiple_choice(*__lowerCAmelCase      )




	@slow
	def   lowercase__   (       self     :  Tuple      ):
							for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__snake_case						 =   TFFlaubertModel.from_pretrained(__lowerCAmelCase      )
													self.assertIsNotNone(__lowerCAmelCase      )





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




	@slow
	def   lowercase__   (       self     :  List[str]      ):
							__snake_case						 =   TFFlaubertModel.from_pretrained('jplu/tf-flaubert-small-cased'      )

							__snake_case						 =   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 !"

							__snake_case						 =   model(__lowerCAmelCase      )[0]
							__snake_case						 =   tf.TensorShape((1, 8, 5_1_2)      )
							self.assertEqual(output.shape       ,		__lowerCAmelCase      )
							# compare the actual values for a slice.
							__snake_case						 =   tf.convert_to_tensor(
							    [
							        [
							            [-1.8768773, -1.566555, 0.27072418],
							            [-1.6920038, -0.5873505, 1.9329599],
							            [-2.9563985, -1.6993835, 1.7972052],
							        ]
							    ]       ,		dtype=tf.floataa       ,		)

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







'''simple docstring'''


import warnings

from ...utils import logging
from .image_processing_videomae import VideoMAEImageProcessor


_lowercase  =			logging.get_logger(__name__)
class 						a_				(			UpperCAmelCase__						):




	def __init__(       self     :  Tuple       ,		*__lowerCAmelCase     :  List[str]       ,		**__lowerCAmelCase     :  List[str]      ):
							warnings.warn(
							    'The class VideoMAEFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
							    ' Please use VideoMAEImageProcessor instead.'       ,		__lowerCAmelCase       ,		)
							super().__init__(*__lowerCAmelCase       ,		**__lowerCAmelCase      )

