





"""simple docstring"""
import io
import os
import unicodedata
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__UpperCamelCase     :						Tuple						       =  logging.get_logger(__name__)

__UpperCamelCase     :						Optional[int]						       =  '''▁'''

__UpperCamelCase     :						str						       =  {'''vocab_file''': '''vocab.txt''', '''sentencepiece_model_ckpt''': '''sentencepiece.bpe.model'''}

__UpperCamelCase     :						Tuple						       =  {
    '''sentencepiece_model_file''': '''sentencepiece.bpe.model''',
    '''vocab_file''': '''vocab.txt''',
}

__UpperCamelCase     :						Tuple						       =  {
    '''vocab_file''': {
        '''ernie-m-base''': '''https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt''',
        '''ernie-m-large''': '''https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt''',
    },
    '''sentencepiece_model_file''': {
        '''ernie-m-base''': '''https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model''',
        '''ernie-m-large''': '''https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model''',
    },
}

__UpperCamelCase     :						Dict						       =  {
    '''ernie-m-base''': 514,
    '''ernie-m-large''': 514,
}

__UpperCamelCase     :						Dict						       =  {
    '''ernie-m-base''': {'''do_lower_case''': False},
    '''ernie-m-large''': {'''do_lower_case''': False},
}







class       a							(   a__  ):
 snake_case__             =       ["input_ids"]

 snake_case__             =       VOCAB_FILES_NAMES
 snake_case__             =       PRETRAINED_INIT_CONFIGURATION
 snake_case__             =       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 snake_case__             =       PRETRAINED_VOCAB_FILES_MAP
 snake_case__             =       RESOURCE_FILES_NAMES



 def __init__(     self				,       _snake_case				,       _snake_case=None				,       _snake_case=False				,       _snake_case="utf8"				,       _snake_case="[UNK]"				,       _snake_case="[SEP]"				,       _snake_case="[PAD]"				,       _snake_case="[CLS]"				,       _snake_case="[MASK]"				,       _snake_case = None				,       **_snake_case				,       ):







  """simple docstring"""






  lowerCAmelCase    				= {} if sp_model_kwargs is None else sp_model_kwargs
  super().__init__(
      do_lower_case=_snake_case				,       unk_token=_snake_case				,       sep_token=_snake_case				,       pad_token=_snake_case				,       cls_token=_snake_case				,       mask_token=_snake_case				,       vocab_file=_snake_case				,       encoding=_snake_case				,       sp_model_kwargs=self.sp_model_kwargs				,       **_snake_case				,       )
  lowerCAmelCase    				= do_lower_case
  lowerCAmelCase    				= sentencepiece_model_ckpt
  lowerCAmelCase    				= spm.SentencePieceProcessor(**self.sp_model_kwargs     )
  self.sp_model.Load(_snake_case     )

  # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning
  if vocab_file is not None:
   lowerCAmelCase    				= self.load_vocab(filepath=_snake_case     )
  else:
   lowerCAmelCase    				= {self.sp_model.id_to_piece(_snake_case     ): id for id in range(self.sp_model.get_piece_size()     )}
  lowerCAmelCase    				= {v: k for k, v in self.vocab.items()}



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  if text is None:
   return None

  lowerCAmelCase    				= self.tokenize(_snake_case     )
  lowerCAmelCase				,lowerCAmelCase    				= '', []

  for i, ch in enumerate(_snake_case     ):
   if ch in self.SP_CHAR_MAPPING:
    lowerCAmelCase    				= self.SP_CHAR_MAPPING.get(_snake_case     )
   else:
    lowerCAmelCase    				= unicodedata.normalize('NFKC'				,       _snake_case     )
   if self.is_whitespace(_snake_case     ):
    continue
   normalized_text += ch
   char_mapping.extend([i] * len(_snake_case     )     )

  lowerCAmelCase				,lowerCAmelCase				,lowerCAmelCase    				= normalized_text, [], 0

  if self.do_lower_case:
   lowerCAmelCase    				= text.lower()

  for token in split_tokens:
   if token[:1] == "▁":
    lowerCAmelCase    				= token[1:]
   lowerCAmelCase    				= text[offset:].index(_snake_case     ) + offset
   lowerCAmelCase    				= start + len(_snake_case     )

   token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1)     )
   lowerCAmelCase    				= end
  return token_mapping



 @property
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return len(self.vocab     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return dict(self.vocab				,       **self.added_tokens_encoder     )



 def __getstate__(     self     ):







  """simple docstring"""






  lowerCAmelCase    				= self.__dict__.copy()
  lowerCAmelCase    				= None
  return state



 def __setstate__(     self				,       _snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= d

  # for backward compatibility
  if not hasattr(self				,       'sp_model_kwargs'     ):
   lowerCAmelCase    				= {}

  lowerCAmelCase    				= spm.SentencePieceProcessor(**self.sp_model_kwargs     )
  self.sp_model.Load(self.sentencepiece_model_ckpt     )



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  return "".join((self.SP_CHAR_MAPPING.get(_snake_case				,       _snake_case     ) for c in text)     )



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case=False				,       _snake_case=64				,       _snake_case=0.1     ):







  """simple docstring"""






  if self.sp_model_kwargs.get('enable_sampling'     ) is True:
   lowerCAmelCase    				= True
  if self.sp_model_kwargs.get('alpha'     ) is not None:
   lowerCAmelCase    				= self.sp_model_kwargs.get('alpha'     )
  if self.sp_model_kwargs.get('nbest_size'     ) is not None:
   lowerCAmelCase    				= self.sp_model_kwargs.get('nbest_size'     )

  if not enable_sampling:
   lowerCAmelCase    				= self.sp_model.EncodeAsPieces(_snake_case     )
  else:
   lowerCAmelCase    				= self.sp_model.SampleEncodeAsPieces(_snake_case				,       _snake_case				,       _snake_case     )
  lowerCAmelCase    				= []
  for pi, piece in enumerate(_snake_case     ):
   if piece == SPIECE_UNDERLINE:
    if not pieces[pi + 1].startswith(_snake_case     ) and pi != 0:
     new_pieces.append(_snake_case     )
     continue
    else:
     continue
   lowerCAmelCase    				= 0
   for i, chunk in enumerate(_snake_case     ):
    if chunk == SPIECE_UNDERLINE:
     continue
    if self.is_ch_char(_snake_case     ) or self.is_punct(_snake_case     ):
     if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
      new_pieces.append(piece[lst_i:i]     )
     new_pieces.append(_snake_case     )
     lowerCAmelCase    				= i + 1
    elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit():
     if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
      new_pieces.append(piece[lst_i:i]     )
     lowerCAmelCase    				= i
    elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit():
     if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
      new_pieces.append(piece[lst_i:i]     )
     lowerCAmelCase    				= i
   if len(_snake_case     ) > lst_i:
    new_pieces.append(piece[lst_i:]     )
  return new_pieces



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= ''.join(_snake_case     ).replace(_snake_case				,       ' '     ).strip()
  return out_string



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= self.convert_ids_to_tokens(_snake_case     )
  lowerCAmelCase    				= ''.join(_snake_case     ).replace(_snake_case				,       ' '     ).strip()
  return out_string



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  return self.vocab.get(_snake_case				,       self.vocab.get(self.unk_token     )     )



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  return self.reverse_vocab.get(_snake_case				,       self.unk_token     )



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case=None     ):







  """simple docstring"""






  if token_ids_a is None:
   return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
  lowerCAmelCase    				= [self.cls_token_id]
  lowerCAmelCase    				= [self.sep_token_id]
  return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case=None     ):







  """simple docstring"""






  if offset_mapping_a is None:
   return [(0, 0)] + offset_mapping_a + [(0, 0)]

  return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)]



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case=None				,       _snake_case=False     ):







  """simple docstring"""






  if already_has_special_tokens:
   if token_ids_a is not None:
    raise ValueError(
        'You should not supply a second sequence if the provided sequence of '
        'ids is already formatted with special tokens for the model.'     )
   return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

  if token_ids_a is not None:
   return [1] + ([0] * len(_snake_case     )) + [1, 1] + ([0] * len(_snake_case     )) + [1]
  return [1] + ([0] * len(_snake_case     )) + [1]



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case = None     ):







  """simple docstring"""






  if token_ids_a is None:
   # [CLS] X [SEP]
   return (len(_snake_case     ) + 2) * [0]

  # [CLS] A [SEP] [SEP] B [SEP]
  return [0] * (len(_snake_case     ) + 1) + [1] * (len(_snake_case     ) + 3)



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  if "\u4e00" <= char <= "\u9fff":
   return True
  return False



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  if ("a" <= char <= "z") or ("A" <= char <= "Z"):
   return True
  return False



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  if char in ",;:.?!~，；：。？！《》【】":
   return True
  return False



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  if char == " " or char == "\t" or char == "\n" or char == "\r":
   return True
  if len(_snake_case     ) == 1:
   lowerCAmelCase    				= unicodedata.category(_snake_case     )
   if cat == "Zs":
    return True
  return False



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= {}
  with io.open(_snake_case				,       'r'				,       encoding='utf-8'     ) as f:
   for index, line in enumerate(_snake_case     ):
    lowerCAmelCase    				= line.rstrip('\n'     )
    lowerCAmelCase    				= int(_snake_case     )

  return token_to_idx



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case = None     ):







  """simple docstring"""






  lowerCAmelCase    				= 0
  if os.path.isdir(_snake_case     ):
   lowerCAmelCase    				= os.path.join(
       _snake_case				,       (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']     )
  else:
   lowerCAmelCase    				= (filename_prefix + '-' if filename_prefix else '') + save_directory
  with open(_snake_case				,       'w'				,       encoding='utf-8'     ) as writer:
   for token, token_index in sorted(self.vocab.items()				,       key=lambda _snake_case     : kv[1]     ):
    if index != token_index:
     logger.warning(
         F'Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.'
         ' Please check that the vocabulary is not corrupted!'     )
     lowerCAmelCase    				= token_index
    writer.write(token + '\n'     )
    index += 1

  lowerCAmelCase    				= os.path.join(_snake_case				,       'sentencepiece.bpe.model'     )
  with open(_snake_case				,       'wb'     ) as fi:
   lowerCAmelCase    				= self.sp_model.serialized_model_proto()
   fi.write(_snake_case     )

  return (vocab_file,)








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







				def __init__(       self     :		Dict		,					UpperCAmelCase__     :		List[Any]		,					UpperCAmelCase__     :		str=13		,					UpperCAmelCase__     :		Tuple=7		,					UpperCAmelCase__     :		Dict=True		,					UpperCAmelCase__     :		Optional[int]=True		,					UpperCAmelCase__     :		Union[str, Any]=True		,					UpperCAmelCase__     :		Tuple=True		,					UpperCAmelCase__     :		Optional[Any]=99		,					UpperCAmelCase__     :		Any=16		,					UpperCAmelCase__     :		Optional[Any]=36		,					UpperCAmelCase__     :		str=6		,					UpperCAmelCase__     :		Any=6		,					UpperCAmelCase__     :		Optional[int]=6		,					UpperCAmelCase__     :		Any=37		,					UpperCAmelCase__     :		List[str]="gelu"		,					UpperCAmelCase__     :		Union[str, Any]=0.1		,					UpperCAmelCase__     :		Optional[int]=0.1		,					UpperCAmelCase__     :		List[str]=512		,					UpperCAmelCase__     :		List[str]=16		,					UpperCAmelCase__     :		Optional[int]=2		,					UpperCAmelCase__     :		Any=0.02		,					UpperCAmelCase__     :		Union[str, Any]=3		,					UpperCAmelCase__     :		List[Any]=4		,					UpperCAmelCase__     :		Tuple=None		,					):
										'''simple docstring'''
										lowercase :							str    		=parent
										lowercase :							int    		=batch_size
										lowercase :							Any    		=seq_length
										lowercase :							int    		=is_training
										lowercase :							str    		=use_input_mask
										lowercase :							int    		=use_token_type_ids
										lowercase :							Dict    		=use_labels
										lowercase :							int    		=vocab_size
										lowercase :							str    		=embedding_size
										lowercase :							Union[str, Any]    		=hidden_size
										lowercase :							Tuple    		=num_hidden_layers
										lowercase :							Any    		=num_hidden_groups
										lowercase :							Union[str, Any]    		=num_attention_heads
										lowercase :							Any    		=intermediate_size
										lowercase :							Tuple    		=hidden_act
										lowercase :							Optional[int]    		=hidden_dropout_prob
										lowercase :							Union[str, Any]    		=attention_probs_dropout_prob
										lowercase :							List[Any]    		=max_position_embeddings
										lowercase :							int    		=type_vocab_size
										lowercase :							int    		=type_sequence_label_size
										lowercase :							Any    		=initializer_range
										lowercase :							List[Any]    		=num_labels
										lowercase :							int    		=num_choices
										lowercase :							Optional[int]    		=scope







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							int    		=ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size   )

										lowercase :							Optional[int]    		=None
										if self.use_input_mask:
																lowercase :							List[str]    		=random_attention_mask([self.batch_size, self.seq_length]   )

										lowercase :							Dict    		=None
										if self.use_token_type_ids:
																lowercase :							List[str]    		=ids_tensor([self.batch_size, self.seq_length]		,					self.type_vocab_size   )

										lowercase :							Tuple    		=None
										lowercase :							Any    		=None
										lowercase :							Dict    		=None
										if self.use_labels:
																lowercase :							int    		=ids_tensor([self.batch_size]		,					self.type_sequence_label_size   )
																lowercase :							str    		=ids_tensor([self.batch_size, self.seq_length]		,					self.num_labels   )
																lowercase :							Optional[Any]    		=ids_tensor([self.batch_size]		,					self.num_choices   )

										lowercase :							Any    		=self.get_config()

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







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''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  lowerCamelCase_	(       self     :		Union[str, Any]		,					UpperCAmelCase__     :		List[Any]		,					UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		Any		,					UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		Optional[Any]		,					UpperCAmelCase__     :		str   ):
										'''simple docstring'''
										lowercase :							int    		=AlbertModel(config=UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							int    		=model(UpperCAmelCase__		,					attention_mask=UpperCAmelCase__		,					token_type_ids=UpperCAmelCase__   )
										lowercase :							Dict    		=model(UpperCAmelCase__		,					token_type_ids=UpperCAmelCase__   )
										lowercase :							int    		=model(UpperCAmelCase__   )
										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  lowerCamelCase_	(       self     :		Optional[Any]		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		Optional[int]		,					UpperCAmelCase__     :		Any		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		Tuple   ):
										'''simple docstring'''
										lowercase :							Tuple    		=AlbertForPreTraining(config=UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							int    		=model(
										    UpperCAmelCase__		,					attention_mask=UpperCAmelCase__		,					token_type_ids=UpperCAmelCase__		,					labels=UpperCAmelCase__		,					sentence_order_label=UpperCAmelCase__		,					)
										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  lowerCamelCase_	(       self     :		List[Any]		,					UpperCAmelCase__     :		Optional[Any]		,					UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		Tuple		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		Optional[int]		,					UpperCAmelCase__     :		int   ):
										'''simple docstring'''
										lowercase :							Tuple    		=AlbertForMaskedLM(config=UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							str    		=model(UpperCAmelCase__		,					attention_mask=UpperCAmelCase__		,					token_type_ids=UpperCAmelCase__		,					labels=UpperCAmelCase__   )
										self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.seq_length, self.vocab_size)   )







				def  lowerCamelCase_	(       self     :		Any		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		List[Any]		,					UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							List[str]    		=AlbertForQuestionAnswering(config=UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							List[str]    		=model(
										    UpperCAmelCase__		,					attention_mask=UpperCAmelCase__		,					token_type_ids=UpperCAmelCase__		,					start_positions=UpperCAmelCase__		,					end_positions=UpperCAmelCase__		,					)
										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  lowerCamelCase_	(       self     :		List[str]		,					UpperCAmelCase__     :		List[Any]		,					UpperCAmelCase__     :		Union[str, Any]		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							Optional[Any]    		=self.num_labels
										lowercase :							Any    		=AlbertForSequenceClassification(UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							Dict    		=model(UpperCAmelCase__		,					attention_mask=UpperCAmelCase__		,					token_type_ids=UpperCAmelCase__		,					labels=UpperCAmelCase__   )
										self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_labels)   )







				def  lowerCamelCase_	(       self     :		Optional[int]		,					UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		Optional[Any]		,					UpperCAmelCase__     :		Optional[int]		,					UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		Any		,					UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		Dict   ):
										'''simple docstring'''
										lowercase :							List[Any]    		=self.num_labels
										lowercase :							str    		=AlbertForTokenClassification(config=UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							int    		=model(UpperCAmelCase__		,					attention_mask=UpperCAmelCase__		,					token_type_ids=UpperCAmelCase__		,					labels=UpperCAmelCase__   )
										self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.seq_length, self.num_labels)   )







				def  lowerCamelCase_	(       self     :		List[str]		,					UpperCAmelCase__     :		Optional[int]		,					UpperCAmelCase__     :		Union[str, Any]		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		Tuple		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		List[str]   ):
										'''simple docstring'''
										lowercase :							Optional[int]    		=self.num_choices
										lowercase :							List[Any]    		=AlbertForMultipleChoice(config=UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							List[Any]    		=input_ids.unsqueeze(1   ).expand(-1		,					self.num_choices		,					-1   ).contiguous()
										lowercase :							int    		=token_type_ids.unsqueeze(1   ).expand(-1		,					self.num_choices		,					-1   ).contiguous()
										lowercase :							int    		=input_mask.unsqueeze(1   ).expand(-1		,					self.num_choices		,					-1   ).contiguous()
										lowercase :							List[str]    		=model(
										    UpperCAmelCase__		,					attention_mask=UpperCAmelCase__		,					token_type_ids=UpperCAmelCase__		,					labels=UpperCAmelCase__		,					)
										self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_choices)   )







				def  lowerCamelCase_	(       self     :		int   ):
										'''simple docstring'''
										lowercase :							Union[str, Any]    		=self.prepare_config_and_inputs()
										(
										    (
										    lowercase
										)		,	(
										    lowercase
										)		,	(
										    lowercase
										)		,	(
										    lowercase
										)		,	(
										    lowercase
										)		,	(
										    lowercase
										)		,	(
										    lowercase
										)		,	
										) :							Dict    		=config_and_inputs
										lowercase :							Optional[Any]    		={'''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      ):
				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  lowerCamelCase_	(       self     :		List[str]		,					UpperCAmelCase__     :		Any		,					UpperCAmelCase__     :		Tuple		,					UpperCAmelCase__     :		int=False   ):
										'''simple docstring'''
										lowercase :							Optional[int]    		=super()._prepare_for_class(UpperCAmelCase__		,					UpperCAmelCase__		,					return_labels=UpperCAmelCase__   )

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







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							Tuple    		=AlbertModelTester(self   )
										lowercase :							Optional[Any]    		=ConfigTester(self		,					config_class=UpperCAmelCase__		,					hidden_size=37   )







				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										self.config_tester.run_common_tests()







				def  lowerCamelCase_	(       self     :		Tuple   ):
										'''simple docstring'''
										lowercase :							Optional[Any]    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										lowercase :							Dict    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_pretraining(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		Dict   ):
										'''simple docstring'''
										lowercase :							Dict    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		str   ):
										'''simple docstring'''
										lowercase :							List[Any]    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_multiple_choice(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		int   ):
										'''simple docstring'''
										lowercase :							str    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		Optional[int]   ):
										'''simple docstring'''
										lowercase :							int    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		List[Any]   ):
										'''simple docstring'''
										lowercase :							Optional[int]    		=self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
																lowercase :							Tuple    		=type
																self.model_tester.create_and_check_model(*UpperCAmelCase__   )







				@slow
				def  lowerCamelCase_	(       self     :		Optional[Any]   ):
										'''simple docstring'''
										for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowercase :							str    		=AlbertModel.from_pretrained(UpperCAmelCase__   )
																self.assertIsNotNone(UpperCAmelCase__   )





@require_torch
class 		__SCREAMING_SNAKE_CASE							(			unittest.TestCase      ):







				@slow
				def  lowerCamelCase_	(       self     :		Tuple   ):
										'''simple docstring'''
										lowercase :							int    		=AlbertModel.from_pretrained('''albert-base-v2'''   )
										lowercase :							Optional[int]    		=torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]   )
										lowercase :							Any    		=torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]   )
										with torch.no_grad():
																lowercase :							Any    		=model(UpperCAmelCase__		,					attention_mask=UpperCAmelCase__   )[0]
										lowercase :							int    		=torch.Size((1, 11, 768)   )
										self.assertEqual(output.shape		,					UpperCAmelCase__   )
										lowercase :							Union[str, Any]    		=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]		,					UpperCAmelCase__		,					atol=1E-4   )   )





