


"""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   _UpperCamelCase  :
							'''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=5_12    ,   __a=16    ,   __a=2    ,   __a=0.0_2    ,   __a=3    ,   __a=4    ,   __a=None    ,   ):
										__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 			snake_case				(     self	):
										__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 			snake_case				(     self	):
										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 			snake_case				(     self    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a	):
										__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 			snake_case				(     self    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a	):
										__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 			snake_case				(     self    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a	):
										__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 			snake_case				(     self    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a	):
										__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 			snake_case				(     self    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a	):
										__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 			snake_case				(     self    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a	):
										__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 			snake_case				(     self    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a	):
										__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 			snake_case				(     self	):
										__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   _UpperCamelCase  (   lowerCAmelCase__       ,lowerCAmelCase__       ,unittest.TestCase		):
							'''simple docstring'''







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

							def 			snake_case				(     self    ,   __a    ,   __a    ,   __a=False	):
										__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 			snake_case				(     self	):
										__lowerCAmelCase				    =			AlbertModelTester(self	)
										__lowerCAmelCase				    =			ConfigTester(self    ,   config_class=__a    ,   hidden_size=37	)

							def 			snake_case				(     self	):
										self.config_tester.run_common_tests()

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__a	)

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_pretraining(*__a	)

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*__a	)

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_multiple_choice(*__a	)

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*__a	)

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*__a	)

							def 			snake_case				(     self	):
										__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 			snake_case				(     self	):
										for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__lowerCAmelCase				    =			AlbertModel.from_pretrained(__a	)
													self.assertIsNotNone(__a	)
@require_torch
class   _UpperCamelCase  (   unittest.TestCase		):
							'''simple docstring'''







							@slow
							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			AlbertModel.from_pretrained("albert-base-v2"	)
										__lowerCAmelCase				    =			torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 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, 7_68)	)
										self.assertEqual(output.shape    ,   __a	)
										__lowerCAmelCase				    =			torch.tensor(
										    [[[-0.6_5_1_3, 1.5_0_3_5, -0.2_7_6_6], [-0.6_5_1_5, 1.5_0_4_6, -0.2_7_8_0], [-0.6_5_1_2, 1.5_0_4_9, -0.2_7_8_4]]]	)

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











def 			A__							(    SCREAMING_SNAKE_CASE__ = 200)   ->    int:
  __snake_case:						Optional[int]   =						[1, 2, 5, 10, 20, 50, 100, 200]
  __snake_case:						List[Any]   =						[0] * (pence + 1)
  __snake_case:						int   =						1  # base case: 1 way to make 0 pence

  for coin in coins:
    for i in range(SCREAMING_SNAKE_CASE__					,					pence + 1					,					1):
      number_of_ways[i] += number_of_ways[i - coin]
  return number_of_ways[pence]


if __name__ == "__main__":
      assert solution(200) == 73_682






