

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



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



      def 		UpperCamelCase_	(    self   :       int	)					->  str:
        _snake_case		=							ids_tensor([self.batch_size, self.seq_length]    ,      self.vocab_size	)

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

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

        _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]    ,      self.num_choices	)

        _snake_case		=							self.get_config()

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



      def 		UpperCamelCase_	(    self   :       Tuple	)					->  Any:
        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=A__    ,      initializer_range=self.initializer_range    ,      )



      def 		UpperCamelCase_	(    self   :       int	)					->  Optional[int]:
        _snake_case		=							self.get_config()
        _snake_case		=							300
        return config



      def 		UpperCamelCase_	(    self   :       Union[str, Any]	)					->  List[Any]:
        (
            (
            _snake_case
        ),  (
            _snake_case
        ),  (
            _snake_case
        ),  (
            _snake_case
        ),  (
            _snake_case
        ),  (
            _snake_case
        ),  (
            _snake_case
        ),  
        )		=							self.prepare_config_and_inputs()

        _snake_case		=							True
        _snake_case		=							floats_tensor([self.batch_size, self.seq_length, self.hidden_size]	)
        _snake_case		=							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 		UpperCamelCase_	(    self   :       Optional[int]    ,      A__   :       str    ,      A__   :       Union[str, Any]    ,      A__   :       Tuple    ,      A__   :       Any    ,      A__   :       Union[str, Any]    ,      A__   :       List[str]    ,      A__   :       Any	)					->  Tuple:
        _snake_case		=							YosoModel(config=A__	)
        model.to(A__	)
        model.eval()
        _snake_case		=							model(A__    ,      attention_mask=A__    ,      token_type_ids=A__	)
        _snake_case		=							model(A__    ,      token_type_ids=A__	)
        _snake_case		=							model(A__	)
        self.parent.assertEqual(result.last_hidden_state.shape    ,      (self.batch_size, self.seq_length, self.hidden_size)	)



      def 		UpperCamelCase_	(    self   :       Any    ,      A__   :       List[Any]    ,      A__   :       Any    ,      A__   :       Optional[int]    ,      A__   :       str    ,      A__   :       List[Any]    ,      A__   :       Optional[int]    ,      A__   :       Optional[int]    ,      A__   :       List[str]    ,      A__   :       List[str]    ,      )					->  int:
        _snake_case		=							True
        _snake_case		=							YosoModel(A__	)
        model.to(A__	)
        model.eval()
        _snake_case		=							model(
            A__    ,      attention_mask=A__    ,      token_type_ids=A__    ,      encoder_hidden_states=A__    ,      encoder_attention_mask=A__    ,      )
        _snake_case		=							model(
            A__    ,      attention_mask=A__    ,      token_type_ids=A__    ,      encoder_hidden_states=A__    ,      )
        _snake_case		=							model(A__    ,      attention_mask=A__    ,      token_type_ids=A__	)
        self.parent.assertEqual(result.last_hidden_state.shape    ,      (self.batch_size, self.seq_length, self.hidden_size)	)



      def 		UpperCamelCase_	(    self   :       Any    ,      A__   :       Optional[int]    ,      A__   :       int    ,      A__   :       List[str]    ,      A__   :       Union[str, Any]    ,      A__   :       List[str]    ,      A__   :       Optional[Any]    ,      A__   :       List[Any]	)					->  Optional[int]:
        _snake_case		=							YosoForMaskedLM(config=A__	)
        model.to(A__	)
        model.eval()
        _snake_case		=							model(A__    ,      attention_mask=A__    ,      token_type_ids=A__    ,      labels=A__	)
        self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.seq_length, self.vocab_size)	)



      def 		UpperCamelCase_	(    self   :       List[str]    ,      A__   :       str    ,      A__   :       List[Any]    ,      A__   :       Optional[Any]    ,      A__   :       Any    ,      A__   :       List[Any]    ,      A__   :       Tuple    ,      A__   :       str	)					->  int:
        _snake_case		=							YosoForQuestionAnswering(config=A__	)
        model.to(A__	)
        model.eval()
        _snake_case		=							model(
            A__    ,      attention_mask=A__    ,      token_type_ids=A__    ,      start_positions=A__    ,      end_positions=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 		UpperCamelCase_	(    self   :       Dict    ,      A__   :       Union[str, Any]    ,      A__   :       List[Any]    ,      A__   :       Dict    ,      A__   :       Dict    ,      A__   :       Dict    ,      A__   :       Tuple    ,      A__   :       Optional[Any]	)					->  str:
        _snake_case		=							self.num_labels
        _snake_case		=							YosoForSequenceClassification(A__	)
        model.to(A__	)
        model.eval()
        _snake_case		=							model(A__    ,      attention_mask=A__    ,      token_type_ids=A__    ,      labels=A__	)
        self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.num_labels)	)



      def 		UpperCamelCase_	(    self   :       str    ,      A__   :       Any    ,      A__   :       Optional[int]    ,      A__   :       Optional[int]    ,      A__   :       List[Any]    ,      A__   :       List[str]    ,      A__   :       List[Any]    ,      A__   :       Optional[Any]	)					->  Optional[Any]:
        _snake_case		=							self.num_labels
        _snake_case		=							YosoForTokenClassification(config=A__	)
        model.to(A__	)
        model.eval()
        _snake_case		=							model(A__    ,      attention_mask=A__    ,      token_type_ids=A__    ,      labels=A__	)
        self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.seq_length, self.num_labels)	)



      def 		UpperCamelCase_	(    self   :       List[str]    ,      A__   :       List[str]    ,      A__   :       Tuple    ,      A__   :       str    ,      A__   :       int    ,      A__   :       int    ,      A__   :       Dict    ,      A__   :       Dict	)					->  Dict:
        _snake_case		=							self.num_choices
        _snake_case		=							YosoForMultipleChoice(config=A__	)
        model.to(A__	)
        model.eval()
        _snake_case		=							input_ids.unsqueeze(1	).expand(-1    ,      self.num_choices    ,      -1	).contiguous()
        _snake_case		=							token_type_ids.unsqueeze(1	).expand(-1    ,      self.num_choices    ,      -1	).contiguous()
        _snake_case		=							input_mask.unsqueeze(1	).expand(-1    ,      self.num_choices    ,      -1	).contiguous()
        _snake_case		=							model(
            A__    ,      attention_mask=A__    ,      token_type_ids=A__    ,      labels=A__    ,      )
        self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.num_choices)	)







      def 		UpperCamelCase_	(    self   :       Dict	)					->  Union[str, Any]:
        _snake_case		=							self.prepare_config_and_inputs()
        (
            (
            _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, '''attention_mask''': input_mask}
        return config, inputs_dict



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

      UpperCamelCase_    :	List[Any]		   =       ()
      UpperCamelCase_    :	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 		UpperCamelCase_	(    self   :       Dict	)					->  Union[str, Any]:
        _snake_case		=							YosoModelTester(self	)
        _snake_case		=							ConfigTester(self    ,      config_class=A__    ,      hidden_size=37	)



      def 		UpperCamelCase_	(    self   :       List[Any]	)					->  Any:
        self.config_tester.run_common_tests()



      def 		UpperCamelCase_	(    self   :       List[str]	)					->  int:
        _snake_case		=							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*A__	)



      def 		UpperCamelCase_	(    self   :       str	)					->  Optional[int]:
        _snake_case		=							self.model_tester.prepare_config_and_inputs()
        for type in ["absolute", "relative_key", "relative_key_query"]:
          _snake_case		=							type
          self.model_tester.create_and_check_model(*A__	)



      def 		UpperCamelCase_	(    self   :       str	)					->  Union[str, Any]:
        _snake_case		=							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_lm(*A__	)



      def 		UpperCamelCase_	(    self   :       Dict	)					->  Tuple:
        _snake_case		=							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_multiple_choice(*A__	)



      def 		UpperCamelCase_	(    self   :       Union[str, Any]	)					->  Optional[int]:
        _snake_case		=							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*A__	)



      def 		UpperCamelCase_	(    self   :       Optional[int]	)					->  Optional[Any]:
        _snake_case		=							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*A__	)



      def 		UpperCamelCase_	(    self   :       List[Any]	)					->  List[Any]:
        _snake_case		=							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*A__	)



      @slow
      def 		UpperCamelCase_	(    self   :       List[Any]	)					->  List[Any]:
        for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          _snake_case		=							YosoModel.from_pretrained(A__	)
          self.assertIsNotNone(A__	)







      def 		UpperCamelCase_	(    self   :       Union[str, Any]	)					->  List[Any]:
        return



@require_torch
class 						lowercase_					(						unittest.TestCase  ):



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

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

        _snake_case		=							torch.Size((1, 6, 768)	)
        self.assertEqual(output.shape    ,      A__	)

        _snake_case		=							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]    ,      A__    ,      atol=1e-4	)	)



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

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

        _snake_case		=							50265

        _snake_case		=							torch.Size((1, 6, vocab_size)	)
        self.assertEqual(output.shape    ,      A__	)

        _snake_case		=							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]    ,      A__    ,      atol=1e-4	)	)







      @slow
      def 		UpperCamelCase_	(    self   :       Tuple	)					->  Dict:
        _snake_case		=							YosoForMaskedLM.from_pretrained('''uw-madison/yoso-4096'''	)
        _snake_case		=							torch.arange(4096	).unsqueeze(0	)

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

        _snake_case		=							50265

        _snake_case		=							torch.Size((1, 4096, vocab_size)	)
        self.assertEqual(output.shape    ,      A__	)

        _snake_case		=							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]    ,      A__    ,      atol=1e-4	)	)




from collections import namedtuple

__A    	=			namedtuple('''from_to''', '''from_ to''')

__A    	=			{
    '''atm''': from_to(1, 1),
    '''pascal''': from_to(0.000_0098, 10_13_25),
    '''bar''': from_to(0.98_6923, 1.0_1325),
    '''kilopascal''': from_to(0.0098_6923, 101.325),
    '''megapascal''': from_to(9.8_6923, 0.10_1325),
    '''psi''': from_to(0.06_8046, 14.6959),
    '''inHg''': from_to(0.033_4211, 29.9213),
    '''torr''': from_to(0.0013_1579, 7_60),
}



def    snake_case_(_UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase  )							->			float:



  """simple docstring"""






  if from_type not in PRESSURE_CONVERSION:
    raise ValueError(
        F"""Invalid 'from_type' value: {from_type!r}  Supported values are:\n"""
        + ''', '''.join(_UpperCamelCase  )  )
  if to_type not in PRESSURE_CONVERSION:
    raise ValueError(
        F"""Invalid 'to_type' value: {to_type!r}.  Supported values are:\n"""
        + ''', '''.join(_UpperCamelCase  )  )
  return (
      value * PRESSURE_CONVERSION[from_type].from_ * PRESSURE_CONVERSION[to_type].to
  )


if __name__ == "__main__":
 import doctest

 doctest.testmod()

