





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	,  _lowerCAmelCase	,  _lowerCAmelCase=13	,  _lowerCAmelCase=7	,  _lowerCAmelCase=True	,  _lowerCAmelCase=True	,  _lowerCAmelCase=True	,  _lowerCAmelCase=True	,  _lowerCAmelCase=99	,  _lowerCAmelCase=16	,  _lowerCAmelCase=36	,  _lowerCAmelCase=6	,  _lowerCAmelCase=6	,  _lowerCAmelCase=6	,  _lowerCAmelCase=37	,  _lowerCAmelCase="gelu"	,  _lowerCAmelCase=0.1	,  _lowerCAmelCase=0.1	,  _lowerCAmelCase=512	,  _lowerCAmelCase=16	,  _lowerCAmelCase=2	,  _lowerCAmelCase=0.02	,  _lowerCAmelCase=3	,  _lowerCAmelCase=4	,  _lowerCAmelCase=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 					__magic_name__ ( 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 					__magic_name__ ( 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 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       AlbertModel(config=_lowerCAmelCase	)
										model.to(_lowerCAmelCase	)
										model.eval()
										lowerCamelCase__       =       model(_lowerCAmelCase	,  attention_mask=_lowerCAmelCase	,  token_type_ids=_lowerCAmelCase	)
										lowerCamelCase__       =       model(_lowerCAmelCase	,  token_type_ids=_lowerCAmelCase	)
										lowerCamelCase__       =       model(_lowerCAmelCase	)
										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 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       AlbertForPreTraining(config=_lowerCAmelCase	)
										model.to(_lowerCAmelCase	)
										model.eval()
										lowerCamelCase__       =       model(
										    _lowerCAmelCase	,  attention_mask=_lowerCAmelCase	,  token_type_ids=_lowerCAmelCase	,  labels=_lowerCAmelCase	,  sentence_order_label=_lowerCAmelCase	,  )
										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 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       AlbertForMaskedLM(config=_lowerCAmelCase	)
										model.to(_lowerCAmelCase	)
										model.eval()
										lowerCamelCase__       =       model(_lowerCAmelCase	,  attention_mask=_lowerCAmelCase	,  token_type_ids=_lowerCAmelCase	,  labels=_lowerCAmelCase	)
										self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.seq_length, self.vocab_size)	)





					def 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       AlbertForQuestionAnswering(config=_lowerCAmelCase	)
										model.to(_lowerCAmelCase	)
										model.eval()
										lowerCamelCase__       =       model(
										    _lowerCAmelCase	,  attention_mask=_lowerCAmelCase	,  token_type_ids=_lowerCAmelCase	,  start_positions=_lowerCAmelCase	,  end_positions=_lowerCAmelCase	,  )
										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 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       self.num_labels
										lowerCamelCase__       =       AlbertForSequenceClassification(_lowerCAmelCase	)
										model.to(_lowerCAmelCase	)
										model.eval()
										lowerCamelCase__       =       model(_lowerCAmelCase	,  attention_mask=_lowerCAmelCase	,  token_type_ids=_lowerCAmelCase	,  labels=_lowerCAmelCase	)
										self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.num_labels)	)





					def 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       self.num_labels
										lowerCamelCase__       =       AlbertForTokenClassification(config=_lowerCAmelCase	)
										model.to(_lowerCAmelCase	)
										model.eval()
										lowerCamelCase__       =       model(_lowerCAmelCase	,  attention_mask=_lowerCAmelCase	,  token_type_ids=_lowerCAmelCase	,  labels=_lowerCAmelCase	)
										self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.seq_length, self.num_labels)	)





					def 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       self.num_choices
										lowerCamelCase__       =       AlbertForMultipleChoice(config=_lowerCAmelCase	)
										model.to(_lowerCAmelCase	)
										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(
										    _lowerCAmelCase	,  attention_mask=_lowerCAmelCase	,  token_type_ids=_lowerCAmelCase	,  labels=_lowerCAmelCase	,  )
										self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.num_choices)	)






					def 					__magic_name__ ( 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 SCREAMING_SNAKE_CASE_ (					lowercase_							,       lowercase_							,       unittest.TestCase   ):





					"""simple docstring"""


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





					def 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase=False	):
										lowerCamelCase__       =       super()._prepare_for_class(_lowerCAmelCase	,  _lowerCAmelCase	,  return_labels=_lowerCAmelCase	)

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





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       AlbertModelTester(self	)
										lowerCamelCase__       =       ConfigTester(self	,  config_class=_lowerCAmelCase	,  hidden_size=37	)





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





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowerCAmelCase	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_pretraining(*_lowerCAmelCase	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*_lowerCAmelCase	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_multiple_choice(*_lowerCAmelCase	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*_lowerCAmelCase	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*_lowerCAmelCase	)





					def 					__magic_name__ ( 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(*_lowerCAmelCase	)






					@slow
					def 					__magic_name__ ( self	):
										for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															lowerCamelCase__       =       AlbertModel.from_pretrained(_lowerCAmelCase	)
															self.assertIsNotNone(_lowerCAmelCase	)

@require_torch
class SCREAMING_SNAKE_CASE_ (					unittest.TestCase   ):





					"""simple docstring"""


					@slow
					def 					__magic_name__ ( self	):
										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(_lowerCAmelCase	,  attention_mask=_lowerCAmelCase	)[0]
										lowerCamelCase__       =       torch.Size((1, 11, 768)	)
										self.assertEqual(output.shape	,  _lowerCAmelCase	)
										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]	,  _lowerCAmelCase	,  atol=1E-4	)	)








import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin

class SCREAMING_SNAKE_CASE_ (					unittest.TestCase							,       lowercase_   ):





					"""simple docstring"""


					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       load_tool("text-classification"	)
										self.tool.setup()
										lowerCamelCase__       =       load_tool("text-classification"	,  remote=_lowerCAmelCase	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.tool("That's quite cool"	,  ["positive", "negative"]	)
										self.assertEqual(_lowerCAmelCase	,  "positive"	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.remote_tool("That's quite cool"	,  ["positive", "negative"]	)
										self.assertEqual(_lowerCAmelCase	,  "positive"	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.tool(text="That's quite cool"	,  labels=["positive", "negative"]	)
										self.assertEqual(_lowerCAmelCase	,  "positive"	)






					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.remote_tool(text="That's quite cool"	,  labels=["positive", "negative"]	)
										self.assertEqual(_lowerCAmelCase	,  "positive"	)

