
'''simple docstring'''
import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
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 (
        MODEL_FOR_PRETRAINING_MAPPING,
        AlbertForMaskedLM,
        AlbertForMultipleChoice,
        AlbertForPreTraining,
        AlbertForQuestionAnswering,
        AlbertForSequenceClassification,
        AlbertForTokenClassification,
        AlbertModel,
    )
    from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST


class       _lowerCAmelCase   :







       '''simple docstring'''

       def __init__(self  ,  UpperCAmelCase  ,  UpperCAmelCase=13  ,  UpperCAmelCase=7  ,  UpperCAmelCase=True  ,  UpperCAmelCase=True  ,  UpperCAmelCase=True  ,  UpperCAmelCase=True  ,  UpperCAmelCase=99  ,  UpperCAmelCase=16  ,  UpperCAmelCase=36  ,  UpperCAmelCase=6  ,  UpperCAmelCase=6  ,  UpperCAmelCase=6  ,  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  ,  )					->       Optional[int]:
              _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       =  embedding_size
              _snake_case       =  hidden_size
              _snake_case       =  num_hidden_layers
              _snake_case       =  num_hidden_groups
              _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 	lowercase							(self  )					->       Optional[int]:
              _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 	lowercase							(self  )					->       int:
              return AlbertConfig(
                  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  ,  initializer_range=self.initializer_range  ,  num_hidden_groups=self.num_hidden_groups  ,  )

       def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Any:
              _snake_case       =  AlbertModel(config=_snake_case  )
              model.to(_snake_case  )
              model.eval()
              _snake_case       =  model(_snake_case  ,  attention_mask=_snake_case  ,  token_type_ids=_snake_case  )
              _snake_case       =  model(_snake_case  ,  token_type_ids=_snake_case  )
              _snake_case       =  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  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       str:
              _snake_case       =  AlbertForPreTraining(config=_snake_case  )
              model.to(_snake_case  )
              model.eval()
              _snake_case       =  model(
                  _snake_case  ,  attention_mask=_snake_case  ,  token_type_ids=_snake_case  ,  labels=_snake_case  ,  sentence_order_label=_snake_case  ,  )
              self.parent.assertEqual(result.prediction_logits.shape  ,  (self.batch_size, self.seq_length, self.vocab_size)  )
              self.parent.assertEqual(result.sop_logits.shape  ,  (self.batch_size, config.num_labels)  )

       def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Dict:
              _snake_case       =  AlbertForMaskedLM(config=_snake_case  )
              model.to(_snake_case  )
              model.eval()
              _snake_case       =  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  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Union[str, Any]:
              _snake_case       =  AlbertForQuestionAnswering(config=_snake_case  )
              model.to(_snake_case  )
              model.eval()
              _snake_case       =  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  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Optional[int]:
              _snake_case       =  self.num_labels
              _snake_case       =  AlbertForSequenceClassification(_snake_case  )
              model.to(_snake_case  )
              model.eval()
              _snake_case       =  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  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Optional[Any]:
              _snake_case       =  self.num_labels
              _snake_case       =  AlbertForTokenClassification(config=_snake_case  )
              model.to(_snake_case  )
              model.eval()
              _snake_case       =  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  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Any:
              _snake_case       =  self.num_choices
              _snake_case       =  AlbertForMultipleChoice(config=_snake_case  )
              model.to(_snake_case  )
              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(
                  _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  )					->       int:
              _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       _lowerCAmelCase   (   __snake_case					,							__snake_case					,							unittest.TestCase				):







       '''simple docstring'''

       lowerCAmelCase_ 						=						(
           (
               AlbertModel,
               AlbertForPreTraining,
               AlbertForMaskedLM,
               AlbertForMultipleChoice,
               AlbertForSequenceClassification,
               AlbertForTokenClassification,
               AlbertForQuestionAnswering,
           )
           if is_torch_available()
           else ()
       )
       lowerCAmelCase_ 						=						(
           {
               "feature-extraction": AlbertModel,
               "fill-mask": AlbertForMaskedLM,
               "question-answering": AlbertForQuestionAnswering,
               "text-classification": AlbertForSequenceClassification,
               "token-classification": AlbertForTokenClassification,
               "zero-shot": AlbertForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       lowerCAmelCase_ 						=						True

       def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase=False  )					->       Optional[Any]:
              _snake_case       =  super()._prepare_for_class(_snake_case  ,  _snake_case  ,  return_labels=_snake_case  )

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

       def 	lowercase							(self  )					->       Dict:
              _snake_case       =  AlbertModelTester(self  )
              _snake_case       =  ConfigTester(self  ,  config_class=_snake_case  ,  hidden_size=37  )

       def 	lowercase							(self  )					->       Tuple:
              self.config_tester.run_common_tests()

       def 	lowercase							(self  )					->       Tuple:
              _snake_case       =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*_snake_case  )

       def 	lowercase							(self  )					->       int:
              _snake_case       =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_pretraining(*_snake_case  )

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

       def 	lowercase							(self  )					->       Optional[int]:
              _snake_case       =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_multiple_choice(*_snake_case  )

       def 	lowercase							(self  )					->       Dict:
              _snake_case       =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_question_answering(*_snake_case  )

       def 	lowercase							(self  )					->       Dict:
              _snake_case       =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_sequence_classification(*_snake_case  )

       def 	lowercase							(self  )					->       Optional[Any]:
              _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(*_snake_case  )





       @slow
       def 	lowercase							(self  )					->       List[str]:




              for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     _snake_case       =  AlbertModel.from_pretrained(_snake_case  )
                     self.assertIsNotNone(_snake_case  )


@require_torch
class       _lowerCAmelCase   (   unittest.TestCase				):







       '''simple docstring'''

       @slow
       def 	lowercase							(self  )					->       Union[str, Any]:
              _snake_case       =  AlbertModel.from_pretrained("""albert-base-v2"""  )
              _snake_case       =  torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]  )
              _snake_case       =  torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
              with torch.no_grad():
                     _snake_case       =  model(_snake_case  ,  attention_mask=_snake_case  )[0]
              _snake_case       =  torch.Size((1, 11, 768)  )
              self.assertEqual(output.shape  ,  _snake_case  )
              _snake_case       =  torch.tensor(
                  [[[-0.6513, 1.5035, -0.2766], [-0.6515, 1.5046, -0.2780], [-0.6512, 1.5049, -0.2784]]]  )

              self.assertTrue(torch.allclose(output[:, 1:4, 1:4]  ,  _snake_case  ,  atol=1e-4  )  )

'''simple docstring'''
from __future__ import annotations

import typing
from collections import Counter






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE				):
							_snake_case       =  Counter()
							for base in range(1							, max_perimeter + 1				):
														for perpendicular in range(_SCREAMING_SNAKE_CASE							, max_perimeter + 1				):
																					_snake_case       =  (base * base + perpendicular * perpendicular) ** 0.5
																					if hypotenuse == int(_SCREAMING_SNAKE_CASE				):
																												_snake_case       =  int(base + perpendicular + hypotenuse				)
																												if perimeter > max_perimeter:
																																			continue
																												triplets[perimeter] += 1
							return triplets






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE = 1000				):
							_snake_case       =  pythagorean_triple(_SCREAMING_SNAKE_CASE				)
							return triplets.most_common(1				)[0][0]


if __name__ == "__main__":
				print(f'''Perimeter {solution()} has maximum solutions''')