
import unittest

from transformers import MPNetConfig, 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, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         MPNetForMaskedLM,
         MPNetForMultipleChoice,
         MPNetForQuestionAnswering,
         MPNetForSequenceClassification,
         MPNetForTokenClassification,
         MPNetModel,
     )




class        _SCREAMING_SNAKE_CASE	:
      def __init__(      self		,						lowerCamelCase		,						lowerCamelCase=13		,						lowerCamelCase=7		,						lowerCamelCase=True		,						lowerCamelCase=True		,						lowerCamelCase=False		,						lowerCamelCase=True		,						lowerCamelCase=99		,						lowerCamelCase=64		,						lowerCamelCase=5		,						lowerCamelCase=4		,						lowerCamelCase=64		,						lowerCamelCase="gelu"		,						lowerCamelCase=0.1		,						lowerCamelCase=0.1		,						lowerCamelCase=5_12		,						lowerCamelCase=16		,						lowerCamelCase=2		,						lowerCamelCase=0.0_2		,						lowerCamelCase=3		,						lowerCamelCase=4		,						lowerCamelCase=None		,						):
          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 A_      (      self			):
          return MPNetConfig.from_pretrained("microsoft/mpnet-base"			)
      def A_      (      self			):
          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
          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, input_mask, sequence_labels, token_labels, choice_labels
      def A_      (      self			):
          return MPNetConfig(
              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		,						initializer_range=self.initializer_range		,						)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					MPNetModel(config=lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(lowerCamelCase		,						lowerCamelCase			)
          snake_case__    =					model(lowerCamelCase			)
          self.parent.assertEqual(result.last_hidden_state.shape		,						(self.batch_size, self.seq_length, self.hidden_size)			)
          self.parent.assertEqual(result.pooler_output.shape		,						(self.batch_size, self.hidden_size)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					MPNetForQuestionAnswering(config=lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(
              lowerCamelCase		,						attention_mask=lowerCamelCase		,						start_positions=lowerCamelCase		,						end_positions=lowerCamelCase		,						)
          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 A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					self.num_labels
          snake_case__    =					MPNetForSequenceClassification(lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(lowerCamelCase		,						attention_mask=lowerCamelCase		,						labels=lowerCamelCase			)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.num_labels)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					self.num_choices
          snake_case__    =					MPNetForMultipleChoice(config=lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					input_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(
              lowerCamelCase		,						attention_mask=lowerCamelCase		,						labels=lowerCamelCase		,						)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.num_choices)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					self.num_labels
          snake_case__    =					MPNetForTokenClassification(config=lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(lowerCamelCase		,						attention_mask=lowerCamelCase		,						labels=lowerCamelCase			)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.seq_length, self.num_labels)			)



      def A_      (      self			):
          snake_case__    =					self.prepare_config_and_inputs()
          ((snake_case__)    ,       (snake_case__)    ,       (snake_case__)    ,       (snake_case__)    ,       (snake_case__)    ,       (snake_case__))    =					config_and_inputs
          snake_case__    =					{"input_ids": input_ids, "attention_mask": input_mask}
          return config, inputs_dict





@require_torch
class        _SCREAMING_SNAKE_CASE	(   __UpperCamelCase							,       __UpperCamelCase							,       unittest.TestCase			):
      _A    :		Union[str, Any]     						=  (
          (
              MPNetForMaskedLM,
              MPNetForMultipleChoice,
              MPNetForQuestionAnswering,
              MPNetForSequenceClassification,
              MPNetForTokenClassification,
              MPNetModel,
          )
          if is_torch_available()
          else ()
      )
      _A    :		List[Any]     						=  (
          {
              'feature-extraction': MPNetModel,
              'fill-mask': MPNetForMaskedLM,
              'question-answering': MPNetForQuestionAnswering,
              'text-classification': MPNetForSequenceClassification,
              'token-classification': MPNetForTokenClassification,
              'zero-shot': MPNetForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      _A    :		List[str]     						=  False
      _A    :		Any     						=  True
      def A_      (      self			):
          snake_case__    =					MPNetModelTester(self			)
          snake_case__    =					ConfigTester(self		,						config_class=lowerCamelCase		,						hidden_size=37			)
      def A_      (      self			):
          self.config_tester.run_common_tests()
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_mpnet_model(*lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_mpnet_for_sequence_classification(*lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_mpnet_for_multiple_choice(*lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_mpnet_for_token_classification(*lowerCamelCase			)



      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_mpnet_for_question_answering(*lowerCamelCase			)





@require_torch
class        _SCREAMING_SNAKE_CASE	(   unittest.TestCase			):
      @slow
      def A_      (      self			):
          snake_case__    =					MPNetModel.from_pretrained("microsoft/mpnet-base"			)
          snake_case__    =					torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]]			)
          snake_case__    =					model(lowerCamelCase			)[0]
          snake_case__    =					torch.Size((1, 11, 7_68)			)
          self.assertEqual(output.shape		,						lowerCamelCase			)
          snake_case__    =					torch.tensor(
              [[[-0.0_5_5_0, 0.1_9_4_3, -0.0_7_4_0], [-0.0_5_6_2, 0.2_2_1_1, -0.0_5_7_9], [-0.0_4_3_7, 0.3_3_3_7, -0.0_6_4_1]]]			)
          # compare the actual values for a slice.
          self.assertTrue(torch.allclose(output[:, :3, :3]		,						lowerCamelCase		,						atol=1e-4			)			)





import math

__magic_name__  							=	10
__magic_name__  							=	7
__magic_name__  							=	BALLS_PER_COLOUR * NUM_COLOURS





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase = 20				):
    snake_case__    =					math.comb(__lowerCAmelCase     ,		__lowerCAmelCase				)
    snake_case__    =					math.comb(NUM_BALLS - BALLS_PER_COLOUR     ,		__lowerCAmelCase				)

    snake_case__    =					NUM_COLOURS * (1 - missing_colour / total)

    return F"""{result:.9f}"""


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



