
'''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       ,  _lowercase       ,  _lowercase=13       ,  _lowercase=7       ,  _lowercase=True       ,  _lowercase=True       ,  _lowercase=True       ,  _lowercase=True       ,  _lowercase=99       ,  _lowercase=16       ,  _lowercase=36       ,  _lowercase=6       ,  _lowercase=6       ,  _lowercase=6       ,  _lowercase=37       ,  _lowercase="gelu"       ,  _lowercase=0.1       ,  _lowercase=0.1       ,  _lowercase=512       ,  _lowercase=16       ,  _lowercase=2       ,  _lowercase=0.02       ,  _lowercase=3       ,  _lowercase=4       ,  _lowercase=None       ,  ):

												"""simple docstring"""



												_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    _lowercase      (   self ):

												"""simple docstring"""



												_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    _lowercase      (   self ):

												"""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    _lowercase      (   self       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase ):

												"""simple docstring"""



												_lowerCAmelCase    		=					AlbertModel(config=_lowercase )
												model.to(_lowercase )
												model.eval()
												_lowerCAmelCase    		=					model(_lowercase       ,  attention_mask=_lowercase       ,  token_type_ids=_lowercase )
												_lowerCAmelCase    		=					model(_lowercase       ,  token_type_ids=_lowercase )
												_lowerCAmelCase    		=					model(_lowercase )
												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       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase ):

												"""simple docstring"""



												_lowerCAmelCase    		=					AlbertForPreTraining(config=_lowercase )
												model.to(_lowercase )
												model.eval()
												_lowerCAmelCase    		=					model(
												    _lowercase       ,  attention_mask=_lowercase       ,  token_type_ids=_lowercase       ,  labels=_lowercase       ,  sentence_order_label=_lowercase       ,  )
												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       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase ):

												"""simple docstring"""



												_lowerCAmelCase    		=					AlbertForMaskedLM(config=_lowercase )
												model.to(_lowercase )
												model.eval()
												_lowerCAmelCase    		=					model(_lowercase       ,  attention_mask=_lowercase       ,  token_type_ids=_lowercase       ,  labels=_lowercase )
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.vocab_size) )




						def    _lowercase      (   self       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase ):

												"""simple docstring"""



												_lowerCAmelCase    		=					AlbertForQuestionAnswering(config=_lowercase )
												model.to(_lowercase )
												model.eval()
												_lowerCAmelCase    		=					model(
												    _lowercase       ,  attention_mask=_lowercase       ,  token_type_ids=_lowercase       ,  start_positions=_lowercase       ,  end_positions=_lowercase       ,  )
												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       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.num_labels
												_lowerCAmelCase    		=					AlbertForSequenceClassification(_lowercase )
												model.to(_lowercase )
												model.eval()
												_lowerCAmelCase    		=					model(_lowercase       ,  attention_mask=_lowercase       ,  token_type_ids=_lowercase       ,  labels=_lowercase )
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_labels) )




						def    _lowercase      (   self       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase ):

												"""simple docstring"""



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




						def    _lowercase      (   self       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase       ,  _lowercase ):

												"""simple docstring"""



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




						def    _lowercase      (   self ):

												"""simple docstring"""



												_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_	(						_SCREAMING_SNAKE_CASE			,				_SCREAMING_SNAKE_CASE			,				unittest.TestCase					):






						'''simple docstring'''






						_lowercase						: Optional[int]										=  (
						    (
						        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						: Any										=  True




						def    _lowercase      (   self       ,  _lowercase       ,  _lowercase       ,  _lowercase=False ):

												"""simple docstring"""



												_lowerCAmelCase    		=					super()._prepare_for_class(_lowercase       ,  _lowercase       ,  return_labels=_lowercase )

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




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					AlbertModelTester(self )
												_lowerCAmelCase    		=					ConfigTester(self       ,  config_class=_lowercase       ,  hidden_size=37 )




						def    _lowercase      (   self ):

												"""simple docstring"""



												self.config_tester.run_common_tests()




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_lowercase )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_pretraining(*_lowercase )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*_lowercase )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_multiple_choice(*_lowercase )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*_lowercase )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*_lowercase )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_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(*_lowercase )




						@slow
						def    _lowercase      (   self ):

												"""simple docstring"""



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






@require_torch
class     UpperCAmelCase_	(						unittest.TestCase					):






						'''simple docstring'''






						@slow
						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					AlbertModel.from_pretrained("""albert-base-v2""" )
												_lowerCAmelCase    		=					torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]] )
												_lowerCAmelCase    		=					torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
												with torch.no_grad():
																		_lowerCAmelCase    		=					model(_lowercase       ,  attention_mask=_lowercase )[0]
												_lowerCAmelCase    		=					torch.Size((1, 11, 768) )
												self.assertEqual(output.shape       ,  _lowercase )
												_lowerCAmelCase    		=					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]       ,  _lowercase       ,  atol=1e-4 ) )


'''simple docstring'''



import warnings

from ...utils import logging
from .image_processing_donut import DonutImageProcessor


_lowercase          =						logging.get_logger(__name__)




class     UpperCAmelCase_	(						_SCREAMING_SNAKE_CASE					):






						'''simple docstring'''






						def __init__(   self       ,  *_lowercase       ,  **_lowercase ):

												"""simple docstring"""



												warnings.warn(
												    """The class DonutFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"""
												    """ use DonutImageProcessor instead."""       ,  _lowercase       ,  )
												super().__init__(*_lowercase       ,  **_lowercase )
