





import unittest

from transformers import YosoConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    YosoForMaskedLM,
							    YosoForMultipleChoice,
							    YosoForQuestionAnswering,
							    YosoForSequenceClassification,
							    YosoForTokenClassification,
							    YosoModel,
							)
							from transformers.models.yoso.modeling_yoso import YOSO_PRETRAINED_MODEL_ARCHIVE_LIST

class    __A  :


				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.0_2 ,			UpperCAmelCase_=3 ,			UpperCAmelCase_=4 ,			UpperCAmelCase_=None ,			):
								lowerCamelCase									=parent
								lowerCamelCase									=batch_size
								lowerCamelCase									=seq_length
								lowerCamelCase									=is_training
								lowerCamelCase									=use_input_mask
								lowerCamelCase									=use_token_type_ids
								lowerCamelCase									=use_labels
								lowerCamelCase									=vocab_size
								lowerCamelCase									=hidden_size
								lowerCamelCase									=num_hidden_layers
								lowerCamelCase									=num_attention_heads
								lowerCamelCase									=intermediate_size
								lowerCamelCase									=hidden_act
								lowerCamelCase									=hidden_dropout_prob
								lowerCamelCase									=attention_probs_dropout_prob
								lowerCamelCase									=max_position_embeddings
								lowerCamelCase									=type_vocab_size
								lowerCamelCase									=type_sequence_label_size
								lowerCamelCase									=initializer_range
								lowerCamelCase									=num_labels
								lowerCamelCase									=num_choices
								lowerCamelCase									=scope


				def _snake_case							(		self				):
								lowerCamelCase									=ids_tensor([self.batch_size, self.seq_length] ,			self.vocab_size				)

								lowerCamelCase									=None
								if self.use_input_mask:
												lowerCamelCase									=random_attention_mask([self.batch_size, self.seq_length]				)

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

								lowerCamelCase									=None
								lowerCamelCase									=None
								lowerCamelCase									=None
								if self.use_labels:
												lowerCamelCase									=ids_tensor([self.batch_size] ,			self.type_sequence_label_size				)
												lowerCamelCase									=ids_tensor([self.batch_size, self.seq_length] ,			self.num_labels				)
												lowerCamelCase									=ids_tensor([self.batch_size] ,			self.num_choices				)

								lowerCamelCase									=self.get_config()

								return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


				def _snake_case							(		self				):
								return YosoConfig(
								    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 ,			)


				def _snake_case							(		self				):
								lowerCamelCase									=self.get_config()
								lowerCamelCase									=300
								return config


				def _snake_case							(		self				):
								(
								    (
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	
								)									=self.prepare_config_and_inputs()

								lowerCamelCase									=True
								lowerCamelCase									=floats_tensor([self.batch_size, self.seq_length, self.hidden_size]				)
								lowerCamelCase									=ids_tensor([self.batch_size, self.seq_length] ,			vocab_size=2				)

								return (
								    config,
								    input_ids,
								    token_type_ids,
								    input_mask,
								    sequence_labels,
								    token_labels,
								    choice_labels,
								    encoder_hidden_states,
								    encoder_attention_mask,
								)


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_				):
								lowerCamelCase									=YosoModel(config=UpperCAmelCase_				)
								model.to(UpperCAmelCase_				)
								model.eval()
								lowerCamelCase									=model(UpperCAmelCase_ ,			attention_mask=UpperCAmelCase_ ,			token_type_ids=UpperCAmelCase_				)
								lowerCamelCase									=model(UpperCAmelCase_ ,			token_type_ids=UpperCAmelCase_				)
								lowerCamelCase									=model(UpperCAmelCase_				)
								self.parent.assertEqual(result.last_hidden_state.shape ,			(self.batch_size, self.seq_length, self.hidden_size)				)


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			):
								lowerCamelCase									=True
								lowerCamelCase									=YosoModel(UpperCAmelCase_				)
								model.to(UpperCAmelCase_				)
								model.eval()
								lowerCamelCase									=model(
								    UpperCAmelCase_ ,			attention_mask=UpperCAmelCase_ ,			token_type_ids=UpperCAmelCase_ ,			encoder_hidden_states=UpperCAmelCase_ ,			encoder_attention_mask=UpperCAmelCase_ ,			)
								lowerCamelCase									=model(
								    UpperCAmelCase_ ,			attention_mask=UpperCAmelCase_ ,			token_type_ids=UpperCAmelCase_ ,			encoder_hidden_states=UpperCAmelCase_ ,			)
								lowerCamelCase									=model(UpperCAmelCase_ ,			attention_mask=UpperCAmelCase_ ,			token_type_ids=UpperCAmelCase_				)
								self.parent.assertEqual(result.last_hidden_state.shape ,			(self.batch_size, self.seq_length, self.hidden_size)				)


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_				):
								lowerCamelCase									=YosoForMaskedLM(config=UpperCAmelCase_				)
								model.to(UpperCAmelCase_				)
								model.eval()
								lowerCamelCase									=model(UpperCAmelCase_ ,			attention_mask=UpperCAmelCase_ ,			token_type_ids=UpperCAmelCase_ ,			labels=UpperCAmelCase_				)
								self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.seq_length, self.vocab_size)				)


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_				):
								lowerCamelCase									=YosoForQuestionAnswering(config=UpperCAmelCase_				)
								model.to(UpperCAmelCase_				)
								model.eval()
								lowerCamelCase									=model(
								    UpperCAmelCase_ ,			attention_mask=UpperCAmelCase_ ,			token_type_ids=UpperCAmelCase_ ,			start_positions=UpperCAmelCase_ ,			end_positions=UpperCAmelCase_ ,			)
								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 ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_				):
								lowerCamelCase									=self.num_labels
								lowerCamelCase									=YosoForSequenceClassification(UpperCAmelCase_				)
								model.to(UpperCAmelCase_				)
								model.eval()
								lowerCamelCase									=model(UpperCAmelCase_ ,			attention_mask=UpperCAmelCase_ ,			token_type_ids=UpperCAmelCase_ ,			labels=UpperCAmelCase_				)
								self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.num_labels)				)


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_				):
								lowerCamelCase									=self.num_labels
								lowerCamelCase									=YosoForTokenClassification(config=UpperCAmelCase_				)
								model.to(UpperCAmelCase_				)
								model.eval()
								lowerCamelCase									=model(UpperCAmelCase_ ,			attention_mask=UpperCAmelCase_ ,			token_type_ids=UpperCAmelCase_ ,			labels=UpperCAmelCase_				)
								self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.seq_length, self.num_labels)				)


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_				):
								lowerCamelCase									=self.num_choices
								lowerCamelCase									=YosoForMultipleChoice(config=UpperCAmelCase_				)
								model.to(UpperCAmelCase_				)
								model.eval()
								lowerCamelCase									=input_ids.unsqueeze(1				).expand(-1 ,			self.num_choices ,			-1				).contiguous()
								lowerCamelCase									=token_type_ids.unsqueeze(1				).expand(-1 ,			self.num_choices ,			-1				).contiguous()
								lowerCamelCase									=input_mask.unsqueeze(1				).expand(-1 ,			self.num_choices ,			-1				).contiguous()
								lowerCamelCase									=model(
								    UpperCAmelCase_ ,			attention_mask=UpperCAmelCase_ ,			token_type_ids=UpperCAmelCase_ ,			labels=UpperCAmelCase_ ,			)
								self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.num_choices)				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.prepare_config_and_inputs()
								(
								    (
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	
								)									=config_and_inputs
								lowerCamelCase									={"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
								return config, inputs_dict




@require_torch
class    __A  (    a     ,       a     ,       unittest.TestCase     ):
				__A  =					(
				    (
				        YosoModel,
				        YosoForMaskedLM,
				        YosoForMultipleChoice,
				        YosoForQuestionAnswering,
				        YosoForSequenceClassification,
				        YosoForTokenClassification,
				    )
				    if is_torch_available()
				    else ()
				)
				__A  =					False
				__A  =					False
				__A  =					False

				__A  =					()
				__A  =					(
				    {
				        """feature-extraction""": YosoModel,
				        """fill-mask""": YosoForMaskedLM,
				        """question-answering""": YosoForQuestionAnswering,
				        """text-classification""": YosoForSequenceClassification,
				        """token-classification""": YosoForTokenClassification,
				        """zero-shot""": YosoForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)


				def _snake_case							(		self				):
								lowerCamelCase									=YosoModelTester(self				)
								lowerCamelCase									=ConfigTester(self ,			config_class=UpperCAmelCase_ ,			hidden_size=37				)


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


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
												lowerCamelCase									=type
												self.model_tester.create_and_check_model(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase_				)


				@slow
				def _snake_case							(		self				):
								for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowerCamelCase									=YosoModel.from_pretrained(UpperCAmelCase_				)
												self.assertIsNotNone(UpperCAmelCase_				)


				def _snake_case							(		self				):
								return




@require_torch
class    __A  (    unittest.TestCase     ):


				@slow
				def _snake_case							(		self				):
								lowerCamelCase									=YosoModel.from_pretrained("""uw-madison/yoso-4096"""				)
								lowerCamelCase									=torch.tensor([[0, 1, 2, 3, 4, 5]]				)

								with torch.no_grad():
												lowerCamelCase									=model(UpperCAmelCase_				)[0]

								lowerCamelCase									=torch.Size((1, 6, 768)				)
								self.assertEqual(output.shape ,			UpperCAmelCase_				)

								lowerCamelCase									=torch.tensor(
								    [[[-0.0_6_1_1, 0.1_2_4_2, 0.0_8_4_0], [0.0_2_8_0, -0.0_0_4_8, 0.1_1_2_5], [0.0_1_0_6, 0.0_2_2_6, 0.0_7_5_1]]]				)

								self.assertTrue(torch.allclose(output[:, :3, :3] ,			UpperCAmelCase_ ,			atol=1E-4				)				)


				@slow
				def _snake_case							(		self				):
								lowerCamelCase									=YosoForMaskedLM.from_pretrained("""uw-madison/yoso-4096"""				)
								lowerCamelCase									=torch.tensor([[0, 1, 2, 3, 4, 5]]				)

								with torch.no_grad():
												lowerCamelCase									=model(UpperCAmelCase_				)[0]

								lowerCamelCase									=50265

								lowerCamelCase									=torch.Size((1, 6, vocab_size)				)
								self.assertEqual(output.shape ,			UpperCAmelCase_				)

								lowerCamelCase									=torch.tensor(
								    [[[-2.1_3_1_3, -3.7_2_8_5, -2.2_4_0_7], [-2.7_0_4_7, -3.3_3_1_4, -2.6_4_0_8], [0.0_6_2_9, -2.5_1_6_6, -0.3_3_5_6]]]				)

								self.assertTrue(torch.allclose(output[:, :3, :3] ,			UpperCAmelCase_ ,			atol=1E-4				)				)


				@slow
				def _snake_case							(		self				):
								lowerCamelCase									=YosoForMaskedLM.from_pretrained("""uw-madison/yoso-4096"""				)
								lowerCamelCase									=torch.arange(4096				).unsqueeze(0				)

								with torch.no_grad():
												lowerCamelCase									=model(UpperCAmelCase_				)[0]

								lowerCamelCase									=50265

								lowerCamelCase									=torch.Size((1, 4096, vocab_size)				)
								self.assertEqual(output.shape ,			UpperCAmelCase_				)

								lowerCamelCase									=torch.tensor(
								    [[[-2.3_9_1_4, -4.3_7_4_2, -5.0_9_5_6], [-4.0_9_8_8, -4.2_3_8_4, -7.0_4_0_6], [-3.1_4_2_7, -3.7_1_9_2, -6.6_8_0_0]]]				)

								self.assertTrue(torch.allclose(output[:, :3, :3] ,			UpperCAmelCase_ ,			atol=1E-4				)				)












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCAmelCase__    :      int       					={
    '''configuration_flaubert''': ['''FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FlaubertConfig''', '''FlaubertOnnxConfig'''],
    '''tokenization_flaubert''': ['''FlaubertTokenizer'''],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__    :      int       					=[
							    '''FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''FlaubertForMultipleChoice''',
							    '''FlaubertForQuestionAnswering''',
							    '''FlaubertForQuestionAnsweringSimple''',
							    '''FlaubertForSequenceClassification''',
							    '''FlaubertForTokenClassification''',
							    '''FlaubertModel''',
							    '''FlaubertWithLMHeadModel''',
							    '''FlaubertPreTrainedModel''',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__    :      List[str]       					=[
							    '''TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''TFFlaubertForMultipleChoice''',
							    '''TFFlaubertForQuestionAnsweringSimple''',
							    '''TFFlaubertForSequenceClassification''',
							    '''TFFlaubertForTokenClassification''',
							    '''TFFlaubertModel''',
							    '''TFFlaubertPreTrainedModel''',
							    '''TFFlaubertWithLMHeadModel''',
							]


if TYPE_CHECKING:
							from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
							from .tokenization_flaubert import FlaubertTokenizer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flaubert import (
														    FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    FlaubertForMultipleChoice,
														    FlaubertForQuestionAnswering,
														    FlaubertForQuestionAnsweringSimple,
														    FlaubertForSequenceClassification,
														    FlaubertForTokenClassification,
														    FlaubertModel,
														    FlaubertPreTrainedModel,
														    FlaubertWithLMHeadModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_flaubert import (
														    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFFlaubertForMultipleChoice,
														    TFFlaubertForQuestionAnsweringSimple,
														    TFFlaubertForSequenceClassification,
														    TFFlaubertForTokenClassification,
														    TFFlaubertModel,
														    TFFlaubertPreTrainedModel,
														    TFFlaubertWithLMHeadModel,
														)

else:
							import sys

							UpperCAmelCase__    :      List[Any]       					=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





