
"""simple docstring"""
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   _UpperCAmelCase					:
    def __init__(     self    ,     snake_case_    ,     snake_case_=13    ,     snake_case_=7    ,     snake_case_=True    ,     snake_case_=True    ,     snake_case_=True    ,     snake_case_=True    ,     snake_case_=99    ,     snake_case_=32    ,     snake_case_=5    ,     snake_case_=4    ,     snake_case_=37    ,     snake_case_="gelu"    ,     snake_case_=0.1    ,     snake_case_=0.1    ,     snake_case_=5_12    ,     snake_case_=16    ,     snake_case_=2    ,     snake_case_=0.02    ,     snake_case_=3    ,     snake_case_=4    ,     snake_case_=None    ,     ):
      _snake_case  :    Tuple            = parent
      _snake_case  :    Optional[int]            = batch_size
      _snake_case  :    Optional[int]            = seq_length
      _snake_case  :    Dict            = is_training
      _snake_case  :    int            = use_input_mask
      _snake_case  :    str            = use_token_type_ids
      _snake_case  :    Optional[Any]            = use_labels
      _snake_case  :    int            = vocab_size
      _snake_case  :    Optional[Any]            = hidden_size
      _snake_case  :    List[Any]            = num_hidden_layers
      _snake_case  :    int            = num_attention_heads
      _snake_case  :    str            = intermediate_size
      _snake_case  :    Optional[Any]            = hidden_act
      _snake_case  :    List[str]            = hidden_dropout_prob
      _snake_case  :    int            = attention_probs_dropout_prob
      _snake_case  :    str            = max_position_embeddings
      _snake_case  :    str            = type_vocab_size
      _snake_case  :    int            = type_sequence_label_size
      _snake_case  :    List[str]            = initializer_range
      _snake_case  :    Dict            = num_labels
      _snake_case  :    Tuple            = num_choices
      _snake_case  :    Optional[Any]            = scope
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Tuple            = ids_tensor([self.batch_size, self.seq_length]    ,     self.vocab_size  )

      _snake_case  :    List[str]            = None
      if self.use_input_mask:
        _snake_case  :    List[Any]            = random_attention_mask([self.batch_size, self.seq_length]  )

      _snake_case  :    Any            = None
      if self.use_token_type_ids:
        _snake_case  :    Optional[int]            = ids_tensor([self.batch_size, self.seq_length]    ,     self.type_vocab_size  )

      _snake_case  :    Tuple            = None
      _snake_case  :    int            = None
      _snake_case  :    int            = None
      if self.use_labels:
        _snake_case  :    Union[str, Any]            = ids_tensor([self.batch_size]    ,     self.type_sequence_label_size  )
        _snake_case  :    int            = ids_tensor([self.batch_size, self.seq_length]    ,     self.num_labels  )
        _snake_case  :    str            = ids_tensor([self.batch_size]    ,     self.num_choices  )

      _snake_case  :    Optional[int]            = self.get_config()

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

      _snake_case  :    Optional[Any]            = True
      _snake_case  :    Optional[int]            = floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
      _snake_case  :    str            = 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    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    int            = YosoModel(config=snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    Dict            = model(snake_case_    ,     attention_mask=snake_case_    ,     token_type_ids=snake_case_  )
      _snake_case  :    List[Any]            = model(snake_case_    ,     token_type_ids=snake_case_  )
      _snake_case  :    int            = model(snake_case_  )
      self.parent.assertEqual(result.last_hidden_state.shape    ,     (self.batch_size, self.seq_length, self.hidden_size)  )
    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     ):
      _snake_case  :    Any            = True
      _snake_case  :    Any            = YosoModel(snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    str            = model(
          snake_case_    ,     attention_mask=snake_case_    ,     token_type_ids=snake_case_    ,     encoder_hidden_states=snake_case_    ,     encoder_attention_mask=snake_case_    ,     )
      _snake_case  :    Any            = model(
          snake_case_    ,     attention_mask=snake_case_    ,     token_type_ids=snake_case_    ,     encoder_hidden_states=snake_case_    ,     )
      _snake_case  :    Tuple            = 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    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    Any            = YosoForMaskedLM(config=snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    Any            = 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    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    Any            = YosoForQuestionAnswering(config=snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    Union[str, Any]            = 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    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    Optional[int]            = self.num_labels
      _snake_case  :    List[Any]            = YosoForSequenceClassification(snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    Any            = 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    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    Tuple            = self.num_labels
      _snake_case  :    str            = YosoForTokenClassification(config=snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    Optional[int]            = 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    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    str            = self.num_choices
      _snake_case  :    List[str]            = YosoForMultipleChoice(config=snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    Union[str, Any]            = input_ids.unsqueeze(1  ).expand(-1    ,     self.num_choices    ,     -1  ).contiguous()
      _snake_case  :    Optional[Any]            = token_type_ids.unsqueeze(1  ).expand(-1    ,     self.num_choices    ,     -1  ).contiguous()
      _snake_case  :    Any            = input_mask.unsqueeze(1  ).expand(-1    ,     self.num_choices    ,     -1  ).contiguous()
      _snake_case  :    Any            = 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  ):
      _snake_case  :    Optional[Any]            = self.prepare_config_and_inputs()
      (
          (
          _snake_case
      )      ,       (
          _snake_case
      )      ,       (
          _snake_case
      )      ,       (
          _snake_case
      )      ,       (
          _snake_case
      )      ,       (
          _snake_case
      )      ,       (
          _snake_case
      )      ,       
      )  :    Optional[int]            = config_and_inputs
      _snake_case  :    Dict            = {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
      return config, inputs_dict






@require_torch
class   _UpperCAmelCase					(       _snake_case		,       _snake_case		,       unittest.TestCase):
    __lowercase				:			Any	=       (
        (
            YosoModel,
            YosoForMaskedLM,
            YosoForMultipleChoice,
            YosoForQuestionAnswering,
            YosoForSequenceClassification,
            YosoForTokenClassification,
        )
        if is_torch_available()
        else ()
    )
    __lowercase				:			List[str]	=       False
    __lowercase				:			Any	=       False
    __lowercase				:			List[str]	=       False

    __lowercase				:			Optional[Any]	=       ()
    __lowercase				:			Dict	=       (
        {
            """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  ):
      _snake_case  :    Optional[int]            = YosoModelTester(self  )
      _snake_case  :    List[Any]            = ConfigTester(self    ,     config_class=snake_case_    ,     hidden_size=37  )
    def        lowerCamelCase__						(     self  ):
      self.config_tester.run_common_tests()
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    int            = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Tuple            = self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
        _snake_case  :    Dict            = type
        self.model_tester.create_and_check_model(*snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    List[Any]            = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    str            = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Dict            = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    List[Any]            = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Optional[Any]            = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*snake_case_  )
    @slow
    def        lowerCamelCase__						(     self  ):
      for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        _snake_case  :    Optional[int]            = YosoModel.from_pretrained(snake_case_  )
        self.assertIsNotNone(snake_case_  )


    def        lowerCamelCase__						(     self  ):
      return






@require_torch
class   _UpperCAmelCase					(       unittest.TestCase):
    @slow
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    List[str]            = YosoModel.from_pretrained("uw-madison/yoso-4096"  )
      _snake_case  :    Tuple            = torch.tensor([[0, 1, 2, 3, 4, 5]]  )

      with torch.no_grad():
        _snake_case  :    str            = model(snake_case_  )[0]

      _snake_case  :    Any            = torch.Size((1, 6, 7_68)  )
      self.assertEqual(output.shape    ,     snake_case_  )

      _snake_case  :    str            = torch.tensor(
          [[[-0.0611, 0.1242, 0.0840], [0.0280, -0.0048, 0.1125], [0.0106, 0.0226, 0.0751]]]  )

      self.assertTrue(torch.allclose(output[:, :3, :3]    ,     snake_case_    ,     atol=1E-4  )  )
    @slow
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Optional[int]            = YosoForMaskedLM.from_pretrained("uw-madison/yoso-4096"  )
      _snake_case  :    Tuple            = torch.tensor([[0, 1, 2, 3, 4, 5]]  )

      with torch.no_grad():
        _snake_case  :    Tuple            = model(snake_case_  )[0]

      _snake_case  :    Union[str, Any]            = 5_02_65

      _snake_case  :    Optional[Any]            = torch.Size((1, 6, vocab_size)  )
      self.assertEqual(output.shape    ,     snake_case_  )

      _snake_case  :    List[Any]            = torch.tensor(
          [[[-2.1313, -3.7285, -2.2407], [-2.7047, -3.3314, -2.6408], [0.0629, -2.5166, -0.3356]]]  )

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


    @slow
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Dict            = YosoForMaskedLM.from_pretrained("uw-madison/yoso-4096"  )
      _snake_case  :    str            = torch.arange(40_96  ).unsqueeze(0  )

      with torch.no_grad():
        _snake_case  :    Any            = model(snake_case_  )[0]

      _snake_case  :    Optional[Any]            = 5_02_65

      _snake_case  :    Tuple            = torch.Size((1, 40_96, vocab_size)  )
      self.assertEqual(output.shape    ,     snake_case_  )

      _snake_case  :    Optional[int]            = torch.tensor(
          [[[-2.3914, -4.3742, -5.0956], [-4.0988, -4.2384, -7.0406], [-3.1427, -3.7192, -6.6800]]]  )

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







'''simple docstring'''







from ..utils import DummyObject, requires_backends


class      _a    (      metaclass=__a					):
       __a							:	str  							=   ["""torch""", """librosa"""]
       def __init__(      self		:      int  ,							*lowercase		:      Any  ,							**lowercase		:      Optional[int]							):



           '''simple docstring'''

           requires_backends(self  ,							['''torch''', '''librosa''']							)
       @classmethod
       def        A (      cls		:      Optional[int]  ,							*lowercase		:      List[str]  ,							**lowercase		:      str							):



           '''simple docstring'''

           requires_backends(cls  ,							['''torch''', '''librosa''']							)







       @classmethod
       def        A (      cls		:      Dict  ,							*lowercase		:      Optional[int]  ,							**lowercase		:      List[Any]							):



           '''simple docstring'''

           requires_backends(cls  ,							['''torch''', '''librosa''']							)






class      _a    (      metaclass=__a					):
       __a							:	List[Any]  							=   ["""torch""", """librosa"""]
       def __init__(      self		:      int  ,							*lowercase		:      Optional[int]  ,							**lowercase		:      Optional[int]							):



           '''simple docstring'''

           requires_backends(self  ,							['''torch''', '''librosa''']							)
       @classmethod
       def        A (      cls		:      Dict  ,							*lowercase		:      Tuple  ,							**lowercase		:      List[str]							):



           '''simple docstring'''

           requires_backends(cls  ,							['''torch''', '''librosa''']							)







       @classmethod
       def        A (      cls		:      Any  ,							*lowercase		:      Any  ,							**lowercase		:      Tuple							):



           '''simple docstring'''

           requires_backends(cls  ,							['''torch''', '''librosa''']							)




