




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     :

     '''simple docstring'''





     def __init__(	self   :			List[Any]					,    __snake_case   :			Dict					,    __snake_case   :			str=13					,    __snake_case   :			List[str]=7					,    __snake_case   :			Tuple=True					,    __snake_case   :			int=True					,    __snake_case   :			Union[str, Any]=True					,    __snake_case   :			Tuple=True					,    __snake_case   :			Union[str, Any]=99					,    __snake_case   :			Optional[Any]=32					,    __snake_case   :			List[str]=5					,    __snake_case   :			Union[str, Any]=4					,    __snake_case   :			Optional[Any]=37					,    __snake_case   :			List[str]="gelu"					,    __snake_case   :			Optional[Any]=0.1					,    __snake_case   :			List[Any]=0.1					,    __snake_case   :			Dict=5_12					,    __snake_case   :			List[str]=16					,    __snake_case   :			Dict=2					,    __snake_case   :			List[str]=0.02					,    __snake_case   :			Dict=3					,    __snake_case   :			Dict=4					,    __snake_case   :			Optional[int]=None					,    ):
         UpperCAmelCase_							 =     parent
         UpperCAmelCase_							 =     batch_size
         UpperCAmelCase_							 =     seq_length
         UpperCAmelCase_							 =     is_training
         UpperCAmelCase_							 =     use_input_mask
         UpperCAmelCase_							 =     use_token_type_ids
         UpperCAmelCase_							 =     use_labels
         UpperCAmelCase_							 =     vocab_size
         UpperCAmelCase_							 =     hidden_size
         UpperCAmelCase_							 =     num_hidden_layers
         UpperCAmelCase_							 =     num_attention_heads
         UpperCAmelCase_							 =     intermediate_size
         UpperCAmelCase_							 =     hidden_act
         UpperCAmelCase_							 =     hidden_dropout_prob
         UpperCAmelCase_							 =     attention_probs_dropout_prob
         UpperCAmelCase_							 =     max_position_embeddings
         UpperCAmelCase_							 =     type_vocab_size
         UpperCAmelCase_							 =     type_sequence_label_size
         UpperCAmelCase_							 =     initializer_range
         UpperCAmelCase_							 =     num_labels
         UpperCAmelCase_							 =     num_choices
         UpperCAmelCase_							 =     scope
     def   lowerCamelCase_   (	self   :			List[str]				):
         UpperCAmelCase_							 =     ids_tensor([self.batch_size, self.seq_length]					,    self.vocab_size				)

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

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

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

         UpperCAmelCase_							 =     self.get_config()

         return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
     def   lowerCamelCase_   (	self   :			Optional[int]				):
         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=__snake_case					,    initializer_range=self.initializer_range					,    )
     def   lowerCamelCase_   (	self   :			List[Any]				):
         UpperCAmelCase_							 =     self.get_config()
         UpperCAmelCase_							 =     3_00
         return config
     def   lowerCamelCase_   (	self   :			str				):
         (
             (
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							
         )							 =     self.prepare_config_and_inputs()

         UpperCAmelCase_							 =     True
         UpperCAmelCase_							 =     floats_tensor([self.batch_size, self.seq_length, self.hidden_size]				)
         UpperCAmelCase_							 =     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   lowerCamelCase_   (	self   :			Optional[int]					,    __snake_case   :			Tuple					,    __snake_case   :			List[str]					,    __snake_case   :			Dict					,    __snake_case   :			Union[str, Any]					,    __snake_case   :			str					,    __snake_case   :			List[str]					,    __snake_case   :			str				):
         UpperCAmelCase_							 =     YosoModel(config=__snake_case				)
         model.to(__snake_case				)
         model.eval()
         UpperCAmelCase_							 =     model(__snake_case					,    attention_mask=__snake_case					,    token_type_ids=__snake_case				)
         UpperCAmelCase_							 =     model(__snake_case					,    token_type_ids=__snake_case				)
         UpperCAmelCase_							 =     model(__snake_case				)
         self.parent.assertEqual(result.last_hidden_state.shape					,    (self.batch_size, self.seq_length, self.hidden_size)				)
     def   lowerCamelCase_   (	self   :			int					,    __snake_case   :			Dict					,    __snake_case   :			Union[str, Any]					,    __snake_case   :			Optional[Any]					,    __snake_case   :			Dict					,    __snake_case   :			Union[str, Any]					,    __snake_case   :			Dict					,    __snake_case   :			Optional[int]					,    __snake_case   :			List[Any]					,    __snake_case   :			List[Any]					,    ):
         UpperCAmelCase_							 =     True
         UpperCAmelCase_							 =     YosoModel(__snake_case				)
         model.to(__snake_case				)
         model.eval()
         UpperCAmelCase_							 =     model(
             __snake_case					,    attention_mask=__snake_case					,    token_type_ids=__snake_case					,    encoder_hidden_states=__snake_case					,    encoder_attention_mask=__snake_case					,    )
         UpperCAmelCase_							 =     model(
             __snake_case					,    attention_mask=__snake_case					,    token_type_ids=__snake_case					,    encoder_hidden_states=__snake_case					,    )
         UpperCAmelCase_							 =     model(__snake_case					,    attention_mask=__snake_case					,    token_type_ids=__snake_case				)
         self.parent.assertEqual(result.last_hidden_state.shape					,    (self.batch_size, self.seq_length, self.hidden_size)				)
     def   lowerCamelCase_   (	self   :			List[str]					,    __snake_case   :			Dict					,    __snake_case   :			List[str]					,    __snake_case   :			Tuple					,    __snake_case   :			Union[str, Any]					,    __snake_case   :			Dict					,    __snake_case   :			List[str]					,    __snake_case   :			int				):
         UpperCAmelCase_							 =     YosoForMaskedLM(config=__snake_case				)
         model.to(__snake_case				)
         model.eval()
         UpperCAmelCase_							 =     model(__snake_case					,    attention_mask=__snake_case					,    token_type_ids=__snake_case					,    labels=__snake_case				)
         self.parent.assertEqual(result.logits.shape					,    (self.batch_size, self.seq_length, self.vocab_size)				)
     def   lowerCamelCase_   (	self   :			List[str]					,    __snake_case   :			Optional[int]					,    __snake_case   :			str					,    __snake_case   :			Union[str, Any]					,    __snake_case   :			List[str]					,    __snake_case   :			Optional[Any]					,    __snake_case   :			str					,    __snake_case   :			Optional[Any]				):
         UpperCAmelCase_							 =     YosoForQuestionAnswering(config=__snake_case				)
         model.to(__snake_case				)
         model.eval()
         UpperCAmelCase_							 =     model(
             __snake_case					,    attention_mask=__snake_case					,    token_type_ids=__snake_case					,    start_positions=__snake_case					,    end_positions=__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   lowerCamelCase_   (	self   :			str					,    __snake_case   :			Optional[Any]					,    __snake_case   :			List[Any]					,    __snake_case   :			Union[str, Any]					,    __snake_case   :			int					,    __snake_case   :			Optional[int]					,    __snake_case   :			str					,    __snake_case   :			List[str]				):
         UpperCAmelCase_							 =     self.num_labels
         UpperCAmelCase_							 =     YosoForSequenceClassification(__snake_case				)
         model.to(__snake_case				)
         model.eval()
         UpperCAmelCase_							 =     model(__snake_case					,    attention_mask=__snake_case					,    token_type_ids=__snake_case					,    labels=__snake_case				)
         self.parent.assertEqual(result.logits.shape					,    (self.batch_size, self.num_labels)				)
     def   lowerCamelCase_   (	self   :			Dict					,    __snake_case   :			Optional[int]					,    __snake_case   :			List[str]					,    __snake_case   :			List[str]					,    __snake_case   :			List[str]					,    __snake_case   :			Optional[int]					,    __snake_case   :			Optional[int]					,    __snake_case   :			Dict				):
         UpperCAmelCase_							 =     self.num_labels
         UpperCAmelCase_							 =     YosoForTokenClassification(config=__snake_case				)
         model.to(__snake_case				)
         model.eval()
         UpperCAmelCase_							 =     model(__snake_case					,    attention_mask=__snake_case					,    token_type_ids=__snake_case					,    labels=__snake_case				)
         self.parent.assertEqual(result.logits.shape					,    (self.batch_size, self.seq_length, self.num_labels)				)
     def   lowerCamelCase_   (	self   :			Tuple					,    __snake_case   :			int					,    __snake_case   :			str					,    __snake_case   :			Tuple					,    __snake_case   :			Optional[int]					,    __snake_case   :			List[str]					,    __snake_case   :			Any					,    __snake_case   :			Optional[int]				):
         UpperCAmelCase_							 =     self.num_choices
         UpperCAmelCase_							 =     YosoForMultipleChoice(config=__snake_case				)
         model.to(__snake_case				)
         model.eval()
         UpperCAmelCase_							 =     input_ids.unsqueeze(1				).expand(-1					,    self.num_choices					,    -1				).contiguous()
         UpperCAmelCase_							 =     token_type_ids.unsqueeze(1				).expand(-1					,    self.num_choices					,    -1				).contiguous()
         UpperCAmelCase_							 =     input_mask.unsqueeze(1				).expand(-1					,    self.num_choices					,    -1				).contiguous()
         UpperCAmelCase_							 =     model(
             __snake_case					,    attention_mask=__snake_case					,    token_type_ids=__snake_case					,    labels=__snake_case					,    )
         self.parent.assertEqual(result.logits.shape					,    (self.batch_size, self.num_choices)				)




     def   lowerCamelCase_   (	self   :			str				):
         UpperCAmelCase_							 =     self.prepare_config_and_inputs()
         (
             (
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							(
             UpperCAmelCase_
         ) ,							
         )							 =     config_and_inputs
         UpperCAmelCase_							 =     {'''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			):

     '''simple docstring'''





     lowerCAmelCase				:       Dict   		=  (
         (
             YosoModel,
             YosoForMaskedLM,
             YosoForMultipleChoice,
             YosoForQuestionAnswering,
             YosoForSequenceClassification,
             YosoForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     lowerCAmelCase				:       Tuple   		=  False
     lowerCAmelCase				:       Optional[Any]   		=  False
     lowerCAmelCase				:       List[Any]   		=  False

     lowerCAmelCase				:       Tuple   		=  ()
     lowerCAmelCase				:       str   		=  (
         {
             'feature-extraction': YosoModel,
             'fill-mask': YosoForMaskedLM,
             'question-answering': YosoForQuestionAnswering,
             'text-classification': YosoForSequenceClassification,
             'token-classification': YosoForTokenClassification,
             'zero-shot': YosoForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     def   lowerCamelCase_   (	self   :			int				):
         UpperCAmelCase_							 =     YosoModelTester(self				)
         UpperCAmelCase_							 =     ConfigTester(self					,    config_class=__snake_case					,    hidden_size=37				)
     def   lowerCamelCase_   (	self   :			Optional[Any]				):
         self.config_tester.run_common_tests()
     def   lowerCamelCase_   (	self   :			str				):
         UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__snake_case				)
     def   lowerCamelCase_   (	self   :			Optional[int]				):
         UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
             UpperCAmelCase_							 =     type
             self.model_tester.create_and_check_model(*__snake_case				)
     def   lowerCamelCase_   (	self   :			Tuple				):
         UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*__snake_case				)
     def   lowerCamelCase_   (	self   :			int				):
         UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*__snake_case				)
     def   lowerCamelCase_   (	self   :			List[str]				):
         UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*__snake_case				)
     def   lowerCamelCase_   (	self   :			int				):
         UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*__snake_case				)
     def   lowerCamelCase_   (	self   :			Any				):
         UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*__snake_case				)
     @slow
     def   lowerCamelCase_   (	self   :			Optional[int]				):
         for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCAmelCase_							 =     YosoModel.from_pretrained(__snake_case				)
             self.assertIsNotNone(__snake_case				)




     def   lowerCamelCase_   (	self   :			List[Any]				):
         return



@require_torch
class 			a     (   unittest.TestCase			):

     '''simple docstring'''





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

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

         UpperCAmelCase_							 =     torch.Size((1, 6, 7_68)				)
         self.assertEqual(output.shape					,    __snake_case				)

         UpperCAmelCase_							 =     torch.tensor(
             [[[-0.0_611, 0.1_242, 0.0_840], [0.0_280, -0.0_048, 0.1_125], [0.0_106, 0.0_226, 0.0_751]]]				)

         self.assertTrue(torch.allclose(output[:, :3, :3]					,    __snake_case					,    atol=1E-4				)				)
     @slow
     def   lowerCamelCase_   (	self   :			Optional[Any]				):
         UpperCAmelCase_							 =     YosoForMaskedLM.from_pretrained('''uw-madison/yoso-4096'''				)
         UpperCAmelCase_							 =     torch.tensor([[0, 1, 2, 3, 4, 5]]				)

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

         UpperCAmelCase_							 =     5_02_65

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

         UpperCAmelCase_							 =     torch.tensor(
             [[[-2.1_313, -3.7_285, -2.2_407], [-2.7_047, -3.3_314, -2.6_408], [0.0_629, -2.5_166, -0.3_356]]]				)

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




     @slow
     def   lowerCamelCase_   (	self   :			Union[str, Any]				):
         UpperCAmelCase_							 =     YosoForMaskedLM.from_pretrained('''uw-madison/yoso-4096'''				)
         UpperCAmelCase_							 =     torch.arange(40_96				).unsqueeze(0				)

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

         UpperCAmelCase_							 =     5_02_65

         UpperCAmelCase_							 =     torch.Size((1, 40_96, vocab_size)				)
         self.assertEqual(output.shape					,    __snake_case				)

         UpperCAmelCase_							 =     torch.tensor(
             [[[-2.3_914, -4.3_742, -5.0_956], [-4.0_988, -4.2_384, -7.0_406], [-3.1_427, -3.7_192, -6.6_800]]]				)

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











from __future__ import annotations




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						list[int | float]      )  ->							int | float:
    if len(__UpperCamelCase      ) == 0:
        raise ValueError('''find_max() arg is an empty sequence'''      )
    UpperCAmelCase_							 =     nums[0]
    for x in nums:
        if x > max_num:
            UpperCAmelCase_							 =     x
    return max_num


if __name__ == "__main__":
 import doctest

 doctest.testmod(verbose=True)





