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







		"""simple docstring"""






		def __init__(   self		,						__A		,						__A=13		,						__A=7		,						__A=True		,						__A=True		,						__A=True		,						__A=True		,						__A=99		,						__A=16		,						__A=36		,						__A=6		,						__A=6		,						__A=6		,						__A=37		,						__A="gelu"		,						__A=0.1		,						__A=0.1		,						__A=512		,						__A=16		,						__A=2		,						__A=0.02		,						__A=3		,						__A=4		,						__A=None		,						) ->     List[str]:
								_lowerCAmelCase										=parent
								_lowerCAmelCase										=batch_size
								_lowerCAmelCase										=seq_length
								_lowerCAmelCase										=is_training
								_lowerCAmelCase										=use_input_mask
								_lowerCAmelCase										=use_token_type_ids
								_lowerCAmelCase										=use_labels
								_lowerCAmelCase										=vocab_size
								_lowerCAmelCase										=embedding_size
								_lowerCAmelCase										=hidden_size
								_lowerCAmelCase										=num_hidden_layers
								_lowerCAmelCase										=num_hidden_groups
								_lowerCAmelCase										=num_attention_heads
								_lowerCAmelCase										=intermediate_size
								_lowerCAmelCase										=hidden_act
								_lowerCAmelCase										=hidden_dropout_prob
								_lowerCAmelCase										=attention_probs_dropout_prob
								_lowerCAmelCase										=max_position_embeddings
								_lowerCAmelCase										=type_vocab_size
								_lowerCAmelCase										=type_sequence_label_size
								_lowerCAmelCase										=initializer_range
								_lowerCAmelCase										=num_labels
								_lowerCAmelCase										=num_choices
								_lowerCAmelCase										=scope






		def 		UpperCamelCase__       (   self				) ->     Any:
								_lowerCAmelCase										=ids_tensor([self.batch_size, self.seq_length]		,						self.vocab_size				)

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

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

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

								_lowerCAmelCase										=self.get_config()

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






		def 		UpperCamelCase__       (   self				) ->     List[Any]:
								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 		UpperCamelCase__       (   self		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A				) ->     Any:
								_lowerCAmelCase										=AlbertModel(config=__A				)
								model.to(__A				)
								model.eval()
								_lowerCAmelCase										=model(__A		,						attention_mask=__A		,						token_type_ids=__A				)
								_lowerCAmelCase										=model(__A		,						token_type_ids=__A				)
								_lowerCAmelCase										=model(__A				)
								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 		UpperCamelCase__       (   self		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A				) ->     Tuple:
								_lowerCAmelCase										=AlbertForPreTraining(config=__A				)
								model.to(__A				)
								model.eval()
								_lowerCAmelCase										=model(
								    __A		,						attention_mask=__A		,						token_type_ids=__A		,						labels=__A		,						sentence_order_label=__A		,						)
								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 		UpperCamelCase__       (   self		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A				) ->     Any:
								_lowerCAmelCase										=AlbertForMaskedLM(config=__A				)
								model.to(__A				)
								model.eval()
								_lowerCAmelCase										=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		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A				) ->     List[Any]:
								_lowerCAmelCase										=AlbertForQuestionAnswering(config=__A				)
								model.to(__A				)
								model.eval()
								_lowerCAmelCase										=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		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A				) ->     str:
								_lowerCAmelCase										=self.num_labels
								_lowerCAmelCase										=AlbertForSequenceClassification(__A				)
								model.to(__A				)
								model.eval()
								_lowerCAmelCase										=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		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A				) ->     Optional[Any]:
								_lowerCAmelCase										=self.num_labels
								_lowerCAmelCase										=AlbertForTokenClassification(config=__A				)
								model.to(__A				)
								model.eval()
								_lowerCAmelCase										=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		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A		,						__A				) ->     str:
								_lowerCAmelCase										=self.num_choices
								_lowerCAmelCase										=AlbertForMultipleChoice(config=__A				)
								model.to(__A				)
								model.eval()
								_lowerCAmelCase										=input_ids.unsqueeze(1				).expand(-1		,						self.num_choices		,						-1				).contiguous()
								_lowerCAmelCase										=token_type_ids.unsqueeze(1				).expand(-1		,						self.num_choices		,						-1				).contiguous()
								_lowerCAmelCase										=input_mask.unsqueeze(1				).expand(-1		,						self.num_choices		,						-1				).contiguous()
								_lowerCAmelCase										=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				) ->     List[str]:
								_lowerCAmelCase										=self.prepare_config_and_inputs()
								(
								    (
								    _lowerCAmelCase
								)						,				(
								    _lowerCAmelCase
								)						,				(
								    _lowerCAmelCase
								)						,				(
								    _lowerCAmelCase
								)						,				(
								    _lowerCAmelCase
								)						,				(
								    _lowerCAmelCase
								)						,				(
								    _lowerCAmelCase
								)						,				
								)										=config_and_inputs
								_lowerCAmelCase										={'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
								return config, inputs_dict

@require_torch
class   SCREAMING_SNAKE_CASE			(						__lowercase    ,			__lowercase    ,			unittest.TestCase):







		"""simple docstring"""
		lowercase   :      Dict       =							(
		    (
		        AlbertModel,
		        AlbertForPreTraining,
		        AlbertForMaskedLM,
		        AlbertForMultipleChoice,
		        AlbertForSequenceClassification,
		        AlbertForTokenClassification,
		        AlbertForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		lowercase   :      Union[str, Any]       =							(
		    {
		        'feature-extraction': AlbertModel,
		        'fill-mask': AlbertForMaskedLM,
		        'question-answering': AlbertForQuestionAnswering,
		        'text-classification': AlbertForSequenceClassification,
		        'token-classification': AlbertForTokenClassification,
		        'zero-shot': AlbertForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		lowercase   :      int       =							True






		def 		UpperCamelCase__       (   self		,						__A		,						__A		,						__A=False				) ->     int:
								_lowerCAmelCase										=super()._prepare_for_class(__A		,						__A		,						return_labels=__A				)

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






		def 		UpperCamelCase__       (   self				) ->     List[Any]:
								_lowerCAmelCase										=AlbertModelTester(self				)
								_lowerCAmelCase										=ConfigTester(self		,						config_class=__A		,						hidden_size=37				)






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






		def 		UpperCamelCase__       (   self				) ->     int:
								_lowerCAmelCase										=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__A				)






		def 		UpperCamelCase__       (   self				) ->     Any:
								_lowerCAmelCase										=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_pretraining(*__A				)






		def 		UpperCamelCase__       (   self				) ->     Optional[int]:
								_lowerCAmelCase										=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*__A				)






		def 		UpperCamelCase__       (   self				) ->     List[Any]:
								_lowerCAmelCase										=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*__A				)






		def 		UpperCamelCase__       (   self				) ->     Optional[Any]:
								_lowerCAmelCase										=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*__A				)






		def 		UpperCamelCase__       (   self				) ->     List[Any]:
								_lowerCAmelCase										=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*__A				)






		def 		UpperCamelCase__       (   self				) ->     Any:
								_lowerCAmelCase										=self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
														_lowerCAmelCase										=type
														self.model_tester.create_and_check_model(*__A				)






		@slow
		def 		UpperCamelCase__       (   self				) ->     Optional[int]:
								for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														_lowerCAmelCase										=AlbertModel.from_pretrained(__A				)
														self.assertIsNotNone(__A				)

@require_torch
class   SCREAMING_SNAKE_CASE			(						unittest.TestCase):







		"""simple docstring"""






		@slow
		def 		UpperCamelCase__       (   self				) ->     List[Any]:
								_lowerCAmelCase										=AlbertModel.from_pretrained('albert-base-v2'				)
								_lowerCAmelCase										=torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]				)
								_lowerCAmelCase										=torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]				)
								with torch.no_grad():
														_lowerCAmelCase										=model(__A		,						attention_mask=__A				)[0]
								_lowerCAmelCase										=torch.Size((1, 11, 768)				)
								self.assertEqual(output.shape		,						__A				)
								_lowerCAmelCase										=torch.tensor(
								    [[[-0.6_513, 1.5_035, -0.2_766], [-0.6_515, 1.5_046, -0.2_780], [-0.6_512, 1.5_049, -0.2_784]]]				)

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






'''simple docstring'''

from __future__ import annotations



def 							UpperCamelCase__			(			a__      ):


						'''simple docstring'''






						_lowerCAmelCase										=len(a__      ) // 2

						# choose the middle 3 elements
						_lowerCAmelCase										=lst[m - 1 : m + 2]

						# if middle element is peak
						if three[1] > three[0] and three[1] > three[2]:
												return three[1]

						# if increasing, recurse on right
						elif three[0] < three[2]:
												if len(lst[:m]      ) == 2:
																		m -= 1
												return peak(lst[m:]      )

						# decreasing
						else:
												if len(lst[:m]      ) == 2:
																		m += 1
												return peak(lst[:m]      )


if __name__ == "__main__":
							import doctest

							doctest.testmod()





