


'''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 					lowerCAmelCase_     :






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






       def      UpperCamelCase	(   self      )->			Tuple:
            _A				=       ids_tensor([self.batch_size, self.seq_length] ,    self.vocab_size      )

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

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

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

            _A				=       self.get_config()

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






       def      UpperCamelCase	(   self      )->			List[str]:
            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      UpperCamelCase	(   self      )->			int:
            _A				=       self.get_config()
            _A				=       300
            return config






       def      UpperCamelCase	(   self      )->			List[Any]:
            (
                (
                _A
            )		,							(
                _A
            )		,							(
                _A
            )		,							(
                _A
            )		,							(
                _A
            )		,							(
                _A
            )		,							(
                _A
            )		,							
            )				=       self.prepare_config_and_inputs()

            _A				=       True
            _A				=       floats_tensor([self.batch_size, self.seq_length, self.hidden_size]      )
            _A				=       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 ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase      )->			Any:
            _A				=       YosoModel(config=_UpperCamelCase      )
            model.to(_UpperCamelCase      )
            model.eval()
            _A				=       model(_UpperCamelCase ,    attention_mask=_UpperCamelCase ,    token_type_ids=_UpperCamelCase      )
            _A				=       model(_UpperCamelCase ,    token_type_ids=_UpperCamelCase      )
            _A				=       model(_UpperCamelCase      )
            self.parent.assertEqual(result.last_hidden_state.shape ,    (self.batch_size, self.seq_length, self.hidden_size)      )






       def      UpperCamelCase	(   self ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    )->			Union[str, Any]:
            _A				=       True
            _A				=       YosoModel(_UpperCamelCase      )
            model.to(_UpperCamelCase      )
            model.eval()
            _A				=       model(
                _UpperCamelCase ,    attention_mask=_UpperCamelCase ,    token_type_ids=_UpperCamelCase ,    encoder_hidden_states=_UpperCamelCase ,    encoder_attention_mask=_UpperCamelCase ,    )
            _A				=       model(
                _UpperCamelCase ,    attention_mask=_UpperCamelCase ,    token_type_ids=_UpperCamelCase ,    encoder_hidden_states=_UpperCamelCase ,    )
            _A				=       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      UpperCamelCase	(   self ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase      )->			Union[str, Any]:
            _A				=       YosoForMaskedLM(config=_UpperCamelCase      )
            model.to(_UpperCamelCase      )
            model.eval()
            _A				=       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      UpperCamelCase	(   self ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase      )->			Dict:
            _A				=       YosoForQuestionAnswering(config=_UpperCamelCase      )
            model.to(_UpperCamelCase      )
            model.eval()
            _A				=       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      UpperCamelCase	(   self ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase      )->			Dict:
            _A				=       self.num_labels
            _A				=       YosoForSequenceClassification(_UpperCamelCase      )
            model.to(_UpperCamelCase      )
            model.eval()
            _A				=       model(_UpperCamelCase ,    attention_mask=_UpperCamelCase ,    token_type_ids=_UpperCamelCase ,    labels=_UpperCamelCase      )
            self.parent.assertEqual(result.logits.shape ,    (self.batch_size, self.num_labels)      )






       def      UpperCamelCase	(   self ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase      )->			Dict:
            _A				=       self.num_labels
            _A				=       YosoForTokenClassification(config=_UpperCamelCase      )
            model.to(_UpperCamelCase      )
            model.eval()
            _A				=       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      UpperCamelCase	(   self ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase ,    _UpperCamelCase      )->			Optional[Any]:
            _A				=       self.num_choices
            _A				=       YosoForMultipleChoice(config=_UpperCamelCase      )
            model.to(_UpperCamelCase      )
            model.eval()
            _A				=       input_ids.unsqueeze(1      ).expand(-1 ,    self.num_choices ,    -1      ).contiguous()
            _A				=       token_type_ids.unsqueeze(1      ).expand(-1 ,    self.num_choices ,    -1      ).contiguous()
            _A				=       input_mask.unsqueeze(1      ).expand(-1 ,    self.num_choices ,    -1      ).contiguous()
            _A				=       model(
                _UpperCamelCase ,    attention_mask=_UpperCamelCase ,    token_type_ids=_UpperCamelCase ,    labels=_UpperCamelCase ,    )
            self.parent.assertEqual(result.logits.shape ,    (self.batch_size, self.num_choices)      )






       def      UpperCamelCase	(   self      )->			Any:
            _A				=       self.prepare_config_and_inputs()
            (
                (
                _A
            )		,							(
                _A
            )		,							(
                _A
            )		,							(
                _A
            )		,							(
                _A
            )		,							(
                _A
            )		,							(
                _A
            )		,							
            )				=       config_and_inputs
            _A				=       {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
            return config, inputs_dict






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

       __UpperCAmelCase				=()
       __UpperCAmelCase				=(
           {
               '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      )->			Any:
            _A				=       YosoModelTester(self      )
            _A				=       ConfigTester(self ,    config_class=_UpperCamelCase ,    hidden_size=37      )






       def      UpperCamelCase	(   self      )->			Optional[int]:
            self.config_tester.run_common_tests()






       def      UpperCamelCase	(   self      )->			Dict:
            _A				=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*_UpperCamelCase      )






       def      UpperCamelCase	(   self      )->			Tuple:
            _A				=       self.model_tester.prepare_config_and_inputs()
            for type in ["absolute", "relative_key", "relative_key_query"]:
                 _A				=       type
                 self.model_tester.create_and_check_model(*_UpperCamelCase      )






       def      UpperCamelCase	(   self      )->			Tuple:
            _A				=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*_UpperCamelCase      )






       def      UpperCamelCase	(   self      )->			List[str]:
            _A				=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_multiple_choice(*_UpperCamelCase      )






       def      UpperCamelCase	(   self      )->			Optional[int]:
            _A				=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase      )






       def      UpperCamelCase	(   self      )->			Optional[Any]:
            _A				=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*_UpperCamelCase      )






       def      UpperCamelCase	(   self      )->			Optional[int]:
            _A				=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase      )






       @slow
       def      UpperCamelCase	(   self      )->			Optional[int]:
            for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _A				=       YosoModel.from_pretrained(_UpperCamelCase      )
                 self.assertIsNotNone(_UpperCamelCase      )






       def      UpperCamelCase	(   self      )->			List[str]:
            return






@require_torch
class 					lowerCAmelCase_     (    unittest.TestCase  ):






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

            with torch.no_grad():
                 _A				=       model(_UpperCamelCase      )[0]

            _A				=       torch.Size((1, 6, 768)      )
            self.assertEqual(output.shape ,    _UpperCamelCase      )

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






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

            with torch.no_grad():
                 _A				=       model(_UpperCamelCase      )[0]

            _A				=       5_0265

            _A				=       torch.Size((1, 6, vocab_size)      )
            self.assertEqual(output.shape ,    _UpperCamelCase      )

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






       @slow
       def      UpperCamelCase	(   self      )->			List[Any]:
            _A				=       YosoForMaskedLM.from_pretrained('uw-madison/yoso-4096'      )
            _A				=       torch.arange(4096      ).unsqueeze(0      )

            with torch.no_grad():
                 _A				=       model(_UpperCamelCase      )[0]

            _A				=       5_0265

            _A				=       torch.Size((1, 4096, vocab_size)      )
            self.assertEqual(output.shape ,    _UpperCamelCase      )

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









'''simple docstring'''
from itertools import permutations

def 				lowerCamelCase_   (   )				->  Optional[int]:







     """simple docstring"""
     _A				=       list(map(''.join       ,						permutations('0123456789'		)		)		)
     return result[9_9_9_9_9_9]


if __name__ == "__main__":
    print(solution())





