import logging

import torch
from torch import nn
from torch.nn import CrossEntropyLoss, MSELoss

from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_model_forward
from transformers.models.albert.modeling_albert import (
    ALBERT_INPUTS_DOCSTRING,
    ALBERT_START_DOCSTRING,
    AlbertModel,
    AlbertPreTrainedModel,
    AlbertTransformer,
)


lowerCAmelCase__					=				logging.getLogger(__name__)
class        a_				(		SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 def 	__snake_case		(    self      :						Tuple    ,					lowercase__      :						List[Any]    ,					lowercase__      :						Optional[int]    ,					lowercase__      :						str=None    ,					lowercase__      :						List[str]=None):







        '''simple docstring'''



        if current_layer == 0:
               lowerCAmelCase__  			=      self.embedding_hidden_mapping_in(lowercase__)
        else:
               lowerCAmelCase__  			=      hidden_states[0]

        lowerCAmelCase__  			=      int(self.config.num_hidden_layers / self.config.num_hidden_groups)

        # Index of the hidden group
        lowerCAmelCase__  			=      int(current_layer / (self.config.num_hidden_layers / self.config.num_hidden_groups))

        lowerCAmelCase__  			=      self.albert_layer_groups[group_idx](
            lowercase__    ,					lowercase__    ,					head_mask[group_idx * layers_per_group : (group_idx + 1) * layers_per_group]    ,					)
        lowerCAmelCase__  			=      layer_group_output[0]

        return (hidden_states,)






@add_start_docstrings(
    'The bare ALBERT Model transformer with PABEE outputting raw hidden-states without any specific head on top.' ,  SCREAMING_SNAKE_CASE ,  )
class        a_				(		SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 def __init__(    self      :						Tuple    ,					lowercase__      :						Dict):







        '''simple docstring'''



        super().__init__(lowercase__)

        lowerCAmelCase__  			=      AlbertTransformerWithPabee(lowercase__)

        self.init_weights()
        lowerCAmelCase__  			=      0
        lowerCAmelCase__  			=      0
        lowerCAmelCase__  			=      0

        lowerCAmelCase__  			=      0




 def 	__snake_case		(    self      :						Dict    ,					lowercase__      :						Dict):







        '''simple docstring'''



        lowerCAmelCase__  			=      threshold




 def 	__snake_case		(    self      :						Dict    ,					lowercase__      :						Any):







        '''simple docstring'''



        lowerCAmelCase__  			=      patience




 def 	__snake_case		(    self      :						Any):







        '''simple docstring'''



        lowerCAmelCase__  			=      0
        lowerCAmelCase__  			=      0




 def 	__snake_case		(    self      :						int):







        '''simple docstring'''



        lowerCAmelCase__  			=      self.inference_layers_num / self.inference_instances_num
        lowerCAmelCase__  			=      (
            F"""*** Patience = {self.patience} Avg. Inference Layers = {avg_inf_layers:.2f} Speed Up ="""
            F""" {1 - avg_inf_layers / self.config.num_hidden_layers:.2f} ***"""
        )
        print(lowercase__)




 @add_start_docstrings_to_model_forward(lowercase__)
 def 	__snake_case		(    self      :						List[str]    ,					lowercase__      :						Dict=None    ,					lowercase__      :						Tuple=None    ,					lowercase__      :						Optional[Any]=None    ,					lowercase__      :						Any=None    ,					lowercase__      :						Any=None    ,					lowercase__      :						List[str]=None    ,					lowercase__      :						List[str]=None    ,					lowercase__      :						Union[str, Any]=None    ,					lowercase__      :						Any=False    ,					):







        '''simple docstring'''



        if input_ids is not None and inputs_embeds is not None:
               raise ValueError('You cannot specify both input_ids and inputs_embeds at the same time')
        elif input_ids is not None:
               lowerCAmelCase__  			=      input_ids.size()
        elif inputs_embeds is not None:
               lowerCAmelCase__  			=      inputs_embeds.size()[:-1]
        else:
               raise ValueError('You have to specify either input_ids or inputs_embeds')

        lowerCAmelCase__  			=      input_ids.device if input_ids is not None else inputs_embeds.device

        if attention_mask is None:
               lowerCAmelCase__  			=      torch.ones(lowercase__    ,					device=lowercase__)
        if token_type_ids is None:
               lowerCAmelCase__  			=      torch.zeros(lowercase__    ,					dtype=torch.long    ,					device=lowercase__)

        lowerCAmelCase__  			=      attention_mask.unsqueeze(1).unsqueeze(2)
        lowerCAmelCase__  			=      extended_attention_mask.to(dtype=self.dtype)  # fp16 compatibility
        lowerCAmelCase__  			=      (1.0 - extended_attention_mask) * -10_000.0
        lowerCAmelCase__  			=      self.get_head_mask(lowercase__    ,					self.config.num_hidden_layers)

        lowerCAmelCase__  			=      self.embeddings(
            lowercase__    ,					position_ids=lowercase__    ,					token_type_ids=lowercase__    ,					inputs_embeds=lowercase__)
        lowerCAmelCase__  			=      embedding_output

        if self.training:
               lowerCAmelCase__  			=      []
               for i in range(self.config.num_hidden_layers):
                      lowerCAmelCase__  			=      self.encoder.adaptive_forward(
                          lowercase__    ,					current_layer=lowercase__    ,					attention_mask=lowercase__    ,					head_mask=lowercase__    ,					)

                      lowerCAmelCase__  			=      self.pooler_activation(self.pooler(encoder_outputs[0][:, 0]))
                      lowerCAmelCase__  			=      output_layers[i](output_dropout(lowercase__))
                      res.append(lowercase__)
        elif self.patience == 0:  # Use all layers for inference
               lowerCAmelCase__  			=      self.encoder(lowercase__    ,					lowercase__    ,					head_mask=lowercase__)
               lowerCAmelCase__  			=      self.pooler_activation(self.pooler(encoder_outputs[0][:, 0]))
               lowerCAmelCase__  			=      [output_layers[self.config.num_hidden_layers - 1](lowercase__)]
        else:
               lowerCAmelCase__  			=      0
               lowerCAmelCase__  			=      None
               lowerCAmelCase__  			=      0
               for i in range(self.config.num_hidden_layers):
                      calculated_layer_num += 1
                      lowerCAmelCase__  			=      self.encoder.adaptive_forward(
                          lowercase__    ,					current_layer=lowercase__    ,					attention_mask=lowercase__    ,					head_mask=lowercase__    ,					)

                      lowerCAmelCase__  			=      self.pooler_activation(self.pooler(encoder_outputs[0][:, 0]))
                      lowerCAmelCase__  			=      output_layers[i](lowercase__)
                      if regression:
                             lowerCAmelCase__  			=      logits.detach()
                             if patient_result is not None:
                                    lowerCAmelCase__  			=      patient_result.detach()
                             if (patient_result is not None) and torch.abs(patient_result - labels) < self.regression_threshold:
                                    patient_counter += 1
                             else:
                                    lowerCAmelCase__  			=      0
                      else:
                             lowerCAmelCase__  			=      logits.detach().argmax(dim=1)
                             if patient_result is not None:
                                    lowerCAmelCase__  			=      patient_result.detach().argmax(dim=1)
                             if (patient_result is not None) and torch.all(labels.eq(lowercase__)):
                                    patient_counter += 1
                             else:
                                    lowerCAmelCase__  			=      0

                      lowerCAmelCase__  			=      logits
                      if patient_counter == self.patience:
                             break
               lowerCAmelCase__  			=      [patient_result]
               self.inference_layers_num += calculated_layer_num
               self.inference_instances_num += 1

        return res






@add_start_docstrings(
    'Albert Model transformer with PABEE and a sequence classification/regression head on top (a linear layer on top of\n    the pooled output) e.g. for GLUE tasks. ' ,  SCREAMING_SNAKE_CASE ,  )
class        a_				(		SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 def __init__(    self      :						Any    ,					lowercase__      :						str):







        '''simple docstring'''



        super().__init__(lowercase__)
        lowerCAmelCase__  			=      config.num_labels

        lowerCAmelCase__  			=      AlbertModelWithPabee(lowercase__)
        lowerCAmelCase__  			=      nn.Dropout(config.classifier_dropout_prob)
        lowerCAmelCase__  			=      nn.ModuleList(
            [nn.Linear(config.hidden_size    ,					self.config.num_labels) for _ in range(config.num_hidden_layers)])

        self.init_weights()




 @add_start_docstrings_to_model_forward(lowercase__)
 def 	__snake_case		(    self      :						str    ,					lowercase__      :						Tuple=None    ,					lowercase__      :						Optional[Any]=None    ,					lowercase__      :						Tuple=None    ,					lowercase__      :						Tuple=None    ,					lowercase__      :						Dict=None    ,					lowercase__      :						Union[str, Any]=None    ,					lowercase__      :						str=None    ,					):







        '''simple docstring'''



        lowerCAmelCase__  			=      self.albert(
            input_ids=lowercase__    ,					attention_mask=lowercase__    ,					token_type_ids=lowercase__    ,					position_ids=lowercase__    ,					head_mask=lowercase__    ,					inputs_embeds=lowercase__    ,					output_dropout=self.dropout    ,					output_layers=self.classifiers    ,					regression=self.num_labels == 1    ,					)

        lowerCAmelCase__  			=      (logits[-1],)

        if labels is not None:
               lowerCAmelCase__  			=      None
               lowerCAmelCase__  			=      0
               for ix, logits_item in enumerate(lowercase__):
                      if self.num_labels == 1:
                             #  We are doing regression
                             lowerCAmelCase__  			=      MSELoss()
                             lowerCAmelCase__  			=      loss_fct(logits_item.view(-1)    ,					labels.view(-1))
                      else:
                             lowerCAmelCase__  			=      CrossEntropyLoss()
                             lowerCAmelCase__  			=      loss_fct(logits_item.view(-1    ,					self.num_labels)    ,					labels.view(-1))
                      if total_loss is None:
                             lowerCAmelCase__  			=      loss
                      else:
                             total_loss += loss * (ix + 1)
                      total_weights += ix + 1
               lowerCAmelCase__  			=      (total_loss / total_weights,) + outputs

        return outputs

from ..utils import DummyObject, requires_backends
class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[str]    ,					*lowercase__      :						Any    ,					**lowercase__      :						List[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						str    ,					*lowercase__      :						List[str]    ,					**lowercase__      :						List[str]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						str    ,					*lowercase__      :						Dict    ,					**lowercase__      :						List[str]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Dict    ,					*lowercase__      :						int    ,					**lowercase__      :						Dict):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Optional[Any]    ,					*lowercase__      :						Dict    ,					**lowercase__      :						List[str]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Any    ,					*lowercase__      :						int    ,					**lowercase__      :						str):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						str    ,					*lowercase__      :						Dict    ,					**lowercase__      :						int):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[str]    ,					*lowercase__      :						Dict    ,					**lowercase__      :						Dict):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Any    ,					*lowercase__      :						Tuple    ,					**lowercase__      :						Dict):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[Any]    ,					*lowercase__      :						int    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						int    ,					*lowercase__      :						Optional[Any]    ,					**lowercase__      :						Union[str, Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Tuple    ,					*lowercase__      :						Dict    ,					**lowercase__      :						Any):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Tuple    ,					*lowercase__      :						Optional[Any]    ,					**lowercase__      :						Any):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						str    ,					*lowercase__      :						Union[str, Any]    ,					**lowercase__      :						Dict):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						int    ,					*lowercase__      :						Tuple    ,					**lowercase__      :						List[str]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Optional[Any]    ,					*lowercase__      :						List[Any]    ,					**lowercase__      :						Union[str, Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[str]    ,					*lowercase__      :						List[Any]    ,					**lowercase__      :						Any):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						str    ,					*lowercase__      :						Optional[int]    ,					**lowercase__      :						Optional[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						str    ,					*lowercase__      :						Any    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						int    ,					*lowercase__      :						Union[str, Any]    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						str    ,					*lowercase__      :						List[str]    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Any    ,					*lowercase__      :						Dict    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						str    ,					*lowercase__      :						Tuple    ,					**lowercase__      :						List[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						int    ,					*lowercase__      :						Dict    ,					**lowercase__      :						Dict):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[str]    ,					*lowercase__      :						List[Any]    ,					**lowercase__      :						Optional[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[str]    ,					*lowercase__      :						Any    ,					**lowercase__      :						List[str]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						int    ,					*lowercase__      :						Union[str, Any]    ,					**lowercase__      :						Optional[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Tuple    ,					*lowercase__      :						Any    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Dict    ,					*lowercase__      :						Optional[int]    ,					**lowercase__      :						Dict):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[Any]    ,					*lowercase__      :						str    ,					**lowercase__      :						List[str]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Optional[int]    ,					*lowercase__      :						Any    ,					**lowercase__      :						Union[str, Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Optional[int]    ,					*lowercase__      :						List[str]    ,					**lowercase__      :						Optional[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Dict    ,					*lowercase__      :						List[Any]    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Any    ,					*lowercase__      :						Union[str, Any]    ,					**lowercase__      :						Optional[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[Any]    ,					*lowercase__      :						Tuple    ,					**lowercase__      :						Optional[int]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						int    ,					*lowercase__      :						Any    ,					**lowercase__      :						str):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Dict    ,					*lowercase__      :						Dict    ,					**lowercase__      :						List[str]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[Any]    ,					*lowercase__      :						str    ,					**lowercase__      :						Optional[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Optional[int]    ,					*lowercase__      :						str    ,					**lowercase__      :						List[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[str]    ,					*lowercase__      :						Any    ,					**lowercase__      :						Union[str, Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Optional[Any]    ,					*lowercase__      :						int    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[Any]    ,					*lowercase__      :						Union[str, Any]    ,					**lowercase__      :						Optional[int]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[str]    ,					*lowercase__      :						Optional[int]    ,					**lowercase__      :						Optional[int]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Union[str, Any]    ,					*lowercase__      :						Optional[int]    ,					**lowercase__      :						Optional[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Optional[int]    ,					*lowercase__      :						Optional[int]    ,					**lowercase__      :						int):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Any    ,					*lowercase__      :						Dict    ,					**lowercase__      :						Optional[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Any    ,					*lowercase__      :						Tuple    ,					**lowercase__      :						List[str]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Union[str, Any]    ,					*lowercase__      :						Union[str, Any]    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Optional[Any]    ,					*lowercase__      :						Tuple    ,					**lowercase__      :						Optional[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Union[str, Any]    ,					*lowercase__      :						Union[str, Any]    ,					**lowercase__      :						List[str]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Optional[int]    ,					*lowercase__      :						Optional[int]    ,					**lowercase__      :						str):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Optional[int]    ,					*lowercase__      :						Any    ,					**lowercase__      :						Any):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						str    ,					*lowercase__      :						Dict    ,					**lowercase__      :						Optional[Any]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						List[str]    ,					*lowercase__      :						str    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Any    ,					*lowercase__      :						Dict    ,					**lowercase__      :						Tuple):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Tuple    ,					*lowercase__      :						Any    ,					**lowercase__      :						Dict):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Union[str, Any]    ,					*lowercase__      :						Optional[int]    ,					**lowercase__      :						Optional[int]):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])






class        a_				(		metaclass=SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      ['tokenizers']




 def __init__(    self      :						Dict    ,					*lowercase__      :						Optional[int]    ,					**lowercase__      :						str):







        '''simple docstring'''



        requires_backends(self    ,					['tokenizers'])
