



'''simple docstring'''






import unittest

from transformers import MobileBertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, 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 (
         MODEL_FOR_PRETRAINING_MAPPING,
         MobileBertForMaskedLM,
         MobileBertForMultipleChoice,
         MobileBertForNextSentencePrediction,
         MobileBertForPreTraining,
         MobileBertForQuestionAnswering,
         MobileBertForSequenceClassification,
         MobileBertForTokenClassification,
         MobileBertModel,
     )

class 							a__:







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







    def       lowercase_	(				self			:  Any     ):
      a						: Union[str, Any]					       =					ids_tensor([self.batch_size, self.seq_length]						,      self.vocab_size     )

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

      a						: List[Any]					       =					None
      if self.use_token_type_ids:
        a						: Union[str, Any]					       =					ids_tensor([self.batch_size, self.seq_length]						,      self.type_vocab_size     )

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

      a						: Any					       =					self.get_config()

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







    def       lowercase_	(				self			:  str     ):
      return MobileBertConfig(
          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						,      embedding_size=self.embedding_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       lowercase_	(				self			:  Tuple						,      __snake_case			:  List[Any]						,      __snake_case			:  Optional[int]						,      __snake_case			:  Optional[int]						,      __snake_case			:  Union[str, Any]						,      __snake_case			:  List[str]						,      __snake_case			:  str						,      __snake_case			:  int     ):
      a						: List[Any]					       =					MobileBertModel(config=__snake_case     )
      model.to(__snake_case     )
      model.eval()
      a						: str					       =					model(__snake_case						,      attention_mask=__snake_case						,      token_type_ids=__snake_case     )
      a						: List[str]					       =					model(__snake_case						,      token_type_ids=__snake_case     )
      a						: Tuple					       =					model(__snake_case     )

      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       lowercase_	(				self			:  Dict						,      __snake_case			:  str						,      __snake_case			:  str						,      __snake_case			:  Any						,      __snake_case			:  str						,      __snake_case			:  str						,      __snake_case			:  Optional[int]						,      __snake_case			:  Tuple     ):
      a						: List[str]					       =					MobileBertForMaskedLM(config=__snake_case     )
      model.to(__snake_case     )
      model.eval()
      a						: Optional[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       lowercase_	(				self			:  List[str]						,      __snake_case			:  Union[str, Any]						,      __snake_case			:  Optional[int]						,      __snake_case			:  Optional[int]						,      __snake_case			:  Optional[Any]						,      __snake_case			:  Optional[int]						,      __snake_case			:  List[str]						,      __snake_case			:  List[Any]     ):
      a						: List[Any]					       =					MobileBertForNextSentencePrediction(config=__snake_case     )
      model.to(__snake_case     )
      model.eval()
      a						: 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, 2)     )







    def       lowercase_	(				self			:  str						,      __snake_case			:  Any						,      __snake_case			:  Union[str, Any]						,      __snake_case			:  int						,      __snake_case			:  List[Any]						,      __snake_case			:  Optional[int]						,      __snake_case			:  Optional[int]						,      __snake_case			:  Optional[Any]     ):
      a						: Optional[int]					       =					MobileBertForPreTraining(config=__snake_case     )
      model.to(__snake_case     )
      model.eval()
      a						: Optional[Any]					       =					model(
          __snake_case						,      attention_mask=__snake_case						,      token_type_ids=__snake_case						,      labels=__snake_case						,      next_sentence_label=__snake_case						,      )
      self.parent.assertEqual(result.prediction_logits.shape						,      (self.batch_size, self.seq_length, self.vocab_size)     )
      self.parent.assertEqual(result.seq_relationship_logits.shape						,      (self.batch_size, 2)     )







    def       lowercase_	(				self			:  Optional[Any]						,      __snake_case			:  Tuple						,      __snake_case			:  int						,      __snake_case			:  Any						,      __snake_case			:  List[str]						,      __snake_case			:  Dict						,      __snake_case			:  Dict						,      __snake_case			:  Tuple     ):
      a						: List[str]					       =					MobileBertForQuestionAnswering(config=__snake_case     )
      model.to(__snake_case     )
      model.eval()
      a						: 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       lowercase_	(				self			:  int						,      __snake_case			:  Optional[int]						,      __snake_case			:  Optional[int]						,      __snake_case			:  Union[str, Any]						,      __snake_case			:  List[str]						,      __snake_case			:  Optional[int]						,      __snake_case			:  List[str]						,      __snake_case			:  str     ):
      a						: Optional[Any]					       =					self.num_labels
      a						: str					       =					MobileBertForSequenceClassification(__snake_case     )
      model.to(__snake_case     )
      model.eval()
      a						: 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.num_labels)     )







    def       lowercase_	(				self			:  List[str]						,      __snake_case			:  Dict						,      __snake_case			:  Tuple						,      __snake_case			:  Optional[Any]						,      __snake_case			:  List[str]						,      __snake_case			:  Tuple						,      __snake_case			:  str						,      __snake_case			:  Any     ):
      a						: Any					       =					self.num_labels
      a						: Dict					       =					MobileBertForTokenClassification(config=__snake_case     )
      model.to(__snake_case     )
      model.eval()
      a						: Optional[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.num_labels)     )







    def       lowercase_	(				self			:  Optional[Any]						,      __snake_case			:  List[str]						,      __snake_case			:  int						,      __snake_case			:  List[Any]						,      __snake_case			:  Optional[int]						,      __snake_case			:  List[Any]						,      __snake_case			:  Union[str, Any]						,      __snake_case			:  Dict     ):
      a						: Union[str, Any]					       =					self.num_choices
      a						: Dict					       =					MobileBertForMultipleChoice(config=__snake_case     )
      model.to(__snake_case     )
      model.eval()
      a						: str					       =					input_ids.unsqueeze(1     ).expand(-1						,      self.num_choices						,      -1     ).contiguous()
      a						: Optional[Any]					       =					token_type_ids.unsqueeze(1     ).expand(-1						,      self.num_choices						,      -1     ).contiguous()
      a						: Optional[Any]					       =					input_mask.unsqueeze(1     ).expand(-1						,      self.num_choices						,      -1     ).contiguous()
      a						: Optional[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       lowercase_	(				self			:  Union[str, Any]     ):
      a						: Any					       =					self.prepare_config_and_inputs()
      (
          (
          a
      )       ,     (
          a
      )       ,     (
          a
      )       ,     (
          a
      )       ,     (
          a
      )       ,     (
          a
      )       ,     (
          a
      )       ,     
      )						: Optional[int]					       =					config_and_inputs
      a						: List[str]					       =					{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
      return config, inputs_dict

@require_torch
class 							a__( lowerCamelCase__		,			lowerCamelCase__		,			unittest.TestCase     ):
    lowercase__			=   (
        (
            MobileBertModel,
            MobileBertForMaskedLM,
            MobileBertForMultipleChoice,
            MobileBertForNextSentencePrediction,
            MobileBertForPreTraining,
            MobileBertForQuestionAnswering,
            MobileBertForSequenceClassification,
            MobileBertForTokenClassification,
        )
        if is_torch_available()
        else ()
    )
    lowercase__			=   (
        {
            """feature-extraction""": MobileBertModel,
            """fill-mask""": MobileBertForMaskedLM,
            """question-answering""": MobileBertForQuestionAnswering,
            """text-classification""": MobileBertForSequenceClassification,
            """token-classification""": MobileBertForTokenClassification,
            """zero-shot""": MobileBertForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    lowercase__			=   True







    def       lowercase_	(				self			:  List[Any]						,      __snake_case			:  Tuple						,      __snake_case			:  Tuple						,      __snake_case			:  Dict=False     ):
      a						: Union[str, Any]					       =					super()._prepare_for_class(__snake_case						,      __snake_case						,      return_labels=__snake_case     )

      if return_labels:
        if model_class in get_values(__snake_case     ):
          a						: str					       =					torch.zeros(
              (self.model_tester.batch_size, self.model_tester.seq_length)						,      dtype=torch.long						,      device=__snake_case     )
          a						: Tuple					       =					torch.zeros(
              self.model_tester.batch_size						,      dtype=torch.long						,      device=__snake_case     )
      return inputs_dict







    def       lowercase_	(				self			:  Optional[Any]     ):
      a						: List[Any]					       =					MobileBertModelTester(self     )
      a						: Dict					       =					ConfigTester(self						,      config_class=__snake_case						,      hidden_size=37     )







    def       lowercase_	(				self			:  Union[str, Any]     ):
      self.config_tester.run_common_tests()







    def       lowercase_	(				self			:  List[Any]     ):
      a						: Optional[Any]					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_model(*__snake_case     )







    def       lowercase_	(				self			:  Union[str, Any]     ):
      a						: Optional[Any]					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_masked_lm(*__snake_case     )







    def       lowercase_	(				self			:  Union[str, Any]     ):
      a						: List[str]					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_multiple_choice(*__snake_case     )







    def       lowercase_	(				self			:  Any     ):
      a						: Union[str, Any]					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*__snake_case     )







    def       lowercase_	(				self			:  List[Any]     ):
      a						: List[Any]					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_pretraining(*__snake_case     )







    def       lowercase_	(				self			:  int     ):
      a						: int					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_question_answering(*__snake_case     )







    def       lowercase_	(				self			:  str     ):
      a						: Optional[Any]					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_sequence_classification(*__snake_case     )







    def       lowercase_	(				self			:  List[Any]     ):
      a						: List[Any]					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mobilebert_for_token_classification(*__snake_case     )
def 				lowerCamelCase__	(						_A    ):
  return torch.tensor(
      _A			,      dtype=torch.long			,      device=_A			,      )


lowerCAmelCase: Tuple							=						1e-3

@require_torch
@require_sentencepiece
@require_tokenizers
class 							a__( unittest.TestCase     ):







    @slow
    def       lowercase_	(				self			:  Any     ):
      a						: Dict					       =					MobileBertModel.from_pretrained('google/mobilebert-uncased'     ).to(__snake_case     )
      a						: str					       =					_long_tensor([[1_01, 71_10, 10_05, 10_56, 20_23, 1_13_33, 1_74_13, 10_29, 1_02]]     )
      with torch.no_grad():
        a						: str					       =					model(__snake_case     )[0]
      a						: Union[str, Any]					       =					torch.Size((1, 9, 5_12)     )
      self.assertEqual(output.shape						,      __snake_case     )
      a						: Tuple					       =					torch.tensor(
          [
              [
                  [-2.4_7_3_6_5_2_6e0_7, 8.2_6_9_1_6_5_6e0_4, 1.6_5_2_1_8_3_8e0_5],
                  [-5.7_5_4_1_7_0_4e-0_1, 3.9_0_5_6_0_2_2e0_0, 4.4_0_1_1_5_0_7e0_0],
                  [2.6_0_4_7_3_5_9e0_0, 1.5_6_7_7_6_5_2e0_0, -1.7_3_2_4_1_8_8e-0_1],
              ]
          ]						,      device=__snake_case						,      )

      # MobileBERT results range from 10e0 to 10e8. Even a 0.0000001% difference with a value of 10e8 results in a
      # ~1 difference, it's therefore not a good idea to measure using addition.
      # Here, we instead divide the expected result with the result in order to obtain ~1. We then check that the
      # result is held between bounds: 1 - TOLERANCE < expected_result / result < 1 + TOLERANCE
      a						: str					       =					torch.all((expected_slice / output[..., :3, :3]) >= 1 - TOLERANCE     )
      a						: Any					       =					torch.all((expected_slice / output[..., :3, :3]) <= 1 + TOLERANCE     )

      self.assertTrue(lower_bound and upper_bound     )




'''simple docstring'''






import math

class 							a__:







    def __init__(				self			:  int						,      __snake_case			:  Any=0     ):  # a graph with Node 0,1,...,N-1
      a						: List[Any]					       =					n
      a						: Optional[Any]					       =					[
          [math.inf for j in range(0						,      __snake_case     )] for i in range(0						,      __snake_case     )
      ]  # adjacency matrix for weight
      a						: Dict					       =					[
          [math.inf for j in range(0						,      __snake_case     )] for i in range(0						,      __snake_case     )
      ]  # dp[i][j] stores minimum distance from i to j







    def       lowercase_	(				self			:  int						,      __snake_case			:  str						,      __snake_case			:  Tuple						,      __snake_case			:  int     ):
      a						: str					       =					w







    def       lowercase_	(				self			:  int     ):
      for k in range(0						,      self.n     ):
        for i in range(0						,      self.n     ):
          for j in range(0						,      self.n     ):
            a						: str					       =					min(self.dp[i][j]						,      self.dp[i][k] + self.dp[k][j]     )







    def       lowercase_	(				self			:  List[str]						,      __snake_case			:  Any						,      __snake_case			:  List[str]     ):
      return self.dp[u][v]


if __name__ == "__main__":
     lowerCAmelCase: Any							=						Graph(5)
     graph.add_edge(0, 2, 9)
     graph.add_edge(0, 4, 1_0)
     graph.add_edge(1, 3, 5)
     graph.add_edge(2, 3, 7)
     graph.add_edge(3, 0, 1_0)
     graph.add_edge(3, 1, 2)
     graph.add_edge(3, 2, 1)
     graph.add_edge(3, 4, 6)
     graph.add_edge(4, 1, 3)
     graph.add_edge(4, 2, 4)
     graph.add_edge(4, 3, 9)
     graph.floyd_warshall()
     graph.show_min(1, 4)
     graph.show_min(0, 3)