




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    lowercase_		:



						def __init__(			self	:   Union[str, Any]					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   Union[str, Any]=13					,							snake_case__	:   List[Any]=7					,							snake_case__	:   Dict=True					,							snake_case__	:   Any=True					,							snake_case__	:   Optional[int]=True					,							snake_case__	:   Optional[Any]=True					,							snake_case__	:   int=99					,							snake_case__	:   Union[str, Any]=16					,							snake_case__	:   Any=36					,							snake_case__	:   List[str]=6					,							snake_case__	:   Any=6					,							snake_case__	:   int=6					,							snake_case__	:   int=37					,							snake_case__	:   Optional[int]="gelu"					,							snake_case__	:   Tuple=0.1					,							snake_case__	:   Optional[Any]=0.1					,							snake_case__	:   str=5_12					,							snake_case__	:   int=16					,							snake_case__	:   Optional[int]=2					,							snake_case__	:   Union[str, Any]=0.02					,							snake_case__	:   str=3					,							snake_case__	:   str=4					,							snake_case__	:   Dict=None					,							):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							parent
								SCREAMING_SNAKE_CASE_					      =							batch_size
								SCREAMING_SNAKE_CASE_					      =							seq_length
								SCREAMING_SNAKE_CASE_					      =							is_training
								SCREAMING_SNAKE_CASE_					      =							use_input_mask
								SCREAMING_SNAKE_CASE_					      =							use_token_type_ids
								SCREAMING_SNAKE_CASE_					      =							use_labels
								SCREAMING_SNAKE_CASE_					      =							vocab_size
								SCREAMING_SNAKE_CASE_					      =							embedding_size
								SCREAMING_SNAKE_CASE_					      =							hidden_size
								SCREAMING_SNAKE_CASE_					      =							num_hidden_layers
								SCREAMING_SNAKE_CASE_					      =							num_hidden_groups
								SCREAMING_SNAKE_CASE_					      =							num_attention_heads
								SCREAMING_SNAKE_CASE_					      =							intermediate_size
								SCREAMING_SNAKE_CASE_					      =							hidden_act
								SCREAMING_SNAKE_CASE_					      =							hidden_dropout_prob
								SCREAMING_SNAKE_CASE_					      =							attention_probs_dropout_prob
								SCREAMING_SNAKE_CASE_					      =							max_position_embeddings
								SCREAMING_SNAKE_CASE_					      =							type_vocab_size
								SCREAMING_SNAKE_CASE_					      =							type_sequence_label_size
								SCREAMING_SNAKE_CASE_					      =							initializer_range
								SCREAMING_SNAKE_CASE_					      =							num_labels
								SCREAMING_SNAKE_CASE_					      =							num_choices
								SCREAMING_SNAKE_CASE_					      =							scope



						def 	__a					(			self	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							ids_tensor([self.batch_size, self.seq_length]					,							self.vocab_size  )

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

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

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

								SCREAMING_SNAKE_CASE_					      =							self.get_config()

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



						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								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 	__a					(			self	:   Dict					,							snake_case__	:   Dict					,							snake_case__	:   str					,							snake_case__	:   int					,							snake_case__	:   Optional[int]					,							snake_case__	:   str					,							snake_case__	:   List[Any]					,							snake_case__	:   List[str]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							AlbertModel(config=snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							attention_mask=snake_case__					,							token_type_ids=snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							token_type_ids=snake_case__  )
								SCREAMING_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 	__a					(			self	:   Union[str, Any]					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   str					,							snake_case__	:   List[str]					,							snake_case__	:   str					,							snake_case__	:   List[Any]					,							snake_case__	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							AlbertForPreTraining(config=snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_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 	__a					(			self	:   List[str]					,							snake_case__	:   List[str]					,							snake_case__	:   List[str]					,							snake_case__	:   Dict					,							snake_case__	:   List[Any]					,							snake_case__	:   Tuple					,							snake_case__	:   Dict					,							snake_case__	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							AlbertForMaskedLM(config=snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_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 	__a					(			self	:   Any					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Tuple					,							snake_case__	:   str					,							snake_case__	:   Optional[Any]					,							snake_case__	:   List[Any]					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							AlbertForQuestionAnswering(config=snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_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 	__a					(			self	:   str					,							snake_case__	:   List[Any]					,							snake_case__	:   Optional[int]					,							snake_case__	:   List[str]					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   Dict					,							snake_case__	:   List[str]					,							snake_case__	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.num_labels
								SCREAMING_SNAKE_CASE_					      =							AlbertForSequenceClassification(snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_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 	__a					(			self	:   List[str]					,							snake_case__	:   Dict					,							snake_case__	:   int					,							snake_case__	:   List[str]					,							snake_case__	:   Dict					,							snake_case__	:   Dict					,							snake_case__	:   Dict					,							snake_case__	:   Tuple  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.num_labels
								SCREAMING_SNAKE_CASE_					      =							AlbertForTokenClassification(config=snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_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 	__a					(			self	:   List[str]					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   List[str]					,							snake_case__	:   List[Any]					,							snake_case__	:   int					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   List[Any]					,							snake_case__	:   Optional[int]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.num_choices
								SCREAMING_SNAKE_CASE_					      =							AlbertForMultipleChoice(config=snake_case__  )
								model.to(snake_case__  )
								model.eval()
								SCREAMING_SNAKE_CASE_					      =							input_ids.unsqueeze(1  ).expand(-1					,							self.num_choices					,							-1  ).contiguous()
								SCREAMING_SNAKE_CASE_					      =							token_type_ids.unsqueeze(1  ).expand(-1					,							self.num_choices					,							-1  ).contiguous()
								SCREAMING_SNAKE_CASE_					      =							input_mask.unsqueeze(1  ).expand(-1					,							self.num_choices					,							-1  ).contiguous()
								SCREAMING_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 	__a					(			self	:   Union[str, Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.prepare_config_and_inputs()
								(
								    (
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				(
								    SCREAMING_SNAKE_CASE_
								)      ,				
								)					      =							config_and_inputs
								SCREAMING_SNAKE_CASE_					      =							{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
								return config, inputs_dict



@require_torch
class    lowercase_		(SCREAMING_SNAKE_CASE__							,	SCREAMING_SNAKE_CASE__							,	unittest.TestCase ):
						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 	__a					(			self	:   str					,							snake_case__	:   Any					,							snake_case__	:   List[Any]					,							snake_case__	:   Union[str, Any]=False  ):

								"""simple docstring"""

								SCREAMING_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__  ):
												SCREAMING_SNAKE_CASE_					      =							torch.zeros(
												    (self.model_tester.batch_size, self.model_tester.seq_length)					,							dtype=torch.long					,							device=snake_case__  )
												SCREAMING_SNAKE_CASE_					      =							torch.zeros(
												    self.model_tester.batch_size					,							dtype=torch.long					,							device=snake_case__  )
								return inputs_dict



						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							AlbertModelTester(self  )
								SCREAMING_SNAKE_CASE_					      =							ConfigTester(self					,							config_class=snake_case__					,							hidden_size=37  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								self.config_tester.run_common_tests()



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case__  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_pretraining(*snake_case__  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*snake_case__  )



						def 	__a					(			self	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*snake_case__  )



						def 	__a					(			self	:   Dict  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*snake_case__  )



						def 	__a					(			self	:   str  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*snake_case__  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
										SCREAMING_SNAKE_CASE_					      =							type
										self.model_tester.create_and_check_model(*snake_case__  )






						@slow
						def 	__a					(			self	:   Optional[int]  ):

								"""simple docstring"""

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



@require_torch
class    lowercase_		(unittest.TestCase ):



						@slow
						def 	__a					(			self	:   Optional[int]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							AlbertModel.from_pretrained('albert-base-v2'  )
								SCREAMING_SNAKE_CASE_					      =							torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]]  )
								SCREAMING_SNAKE_CASE_					      =							torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
								with torch.no_grad():
										SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							attention_mask=snake_case__  )[0]
								SCREAMING_SNAKE_CASE_					      =							torch.Size((1, 11, 7_68)  )
								self.assertEqual(output.shape					,							snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							torch.tensor(
								    [[[-0.65_13, 1.50_35, -0.27_66], [-0.65_15, 1.50_46, -0.27_80], [-0.65_12, 1.50_49, -0.27_84]]]  )

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





from __future__ import annotations

import math


def 					_a							(					lowerCAmelCase )->	bool:

		if 1 < number < 4:
				# 2 and 3 are primes
				return True
		elif number < 2 or number % 2 == 0 or number % 3 == 0:
				# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
				return False

		# All primes number are in format of 6k +/- 1
		for i in range(5    ,						int(math.sqrt(lowerCAmelCase ) + 1 )    ,						6 ):
				if number % i == 0 or number % (i + 2) == 0:
						return False
		return True


SCREAMING_SNAKE_CASE:     List[str]									= [num for num in range(3, 1_0_0_0_0_1, 2) if not is_prime(num)]


def 					_a							(					lowerCAmelCase )->	list[int]:
		if not isinstance(lowerCAmelCase    ,						lowerCAmelCase ):
				raise ValueError('n must be an integer' )
		if n <= 0:
				raise ValueError('n must be >= 0' )

		SCREAMING_SNAKE_CASE_					      =							[]
		for num in range(len(lowerCAmelCase ) ):
				SCREAMING_SNAKE_CASE_					      =							0
				while 2 * i * i <= odd_composites[num]:
						SCREAMING_SNAKE_CASE_					      =							odd_composites[num] - 2 * i * i
						if is_prime(lowerCAmelCase ):
								break
						i += 1
				else:
						list_nums.append(odd_composites[num] )
						if len(lowerCAmelCase ) == n:
								return list_nums

		return []


def 					_a							(					)->	int:
		return compute_nums(1 )[0]


if __name__ == "__main__":
						print(f"""{solution() = }""")