





'''simple docstring'''


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.bert.modeling_bert import (
    BERT_INPUTS_DOCSTRING,
    BERT_START_DOCSTRING,
    BertEncoder,
    BertModel,
    BertPreTrainedModel,
)


lowerCAmelCase_   :   Any       =					logging.getLogger(__name__)






class       UpperCamelCase__  (		__lowerCAmelCase     ):







	def 						__a   (				self			:   Optional[int] , lowerCamelCase			:   str , lowerCamelCase			:   Union[str, Any] , lowerCamelCase			:   Optional[Any]=None , lowerCamelCase			:   Optional[int]=None		):




				'''simple docstring'''
				a__     = self.layer[current_layer](lowerCamelCase , lowerCamelCase , head_mask[current_layer]		)

				a__     = layer_outputs[0]

				return hidden_states






@add_start_docstrings(
    "The bare Bert Model transformer with PABEE outputting raw hidden-states without any specific head on top."	,__lowerCAmelCase	,)
class       UpperCamelCase__  (		__lowerCAmelCase     ):







	def __init__(				self			:   Any , lowerCamelCase			:   Dict		):




				'''simple docstring'''
				super().__init__(lowerCamelCase		)

				a__     = BertEncoderWithPabee(lowerCamelCase		)

				self.init_weights()
				a__     = 0
				a__     = 0
				a__     = 0

				a__     = 0







	def 						__a   (				self			:   Optional[Any] , lowerCamelCase			:   List[str]		):




				'''simple docstring'''
				a__     = threshold







	def 						__a   (				self			:   str , lowerCamelCase			:   Tuple		):




				'''simple docstring'''
				a__     = patience







	def 						__a   (				self			:   int		):




				'''simple docstring'''
				a__     = 0
				a__     = 0







	def 						__a   (				self			:   int		):




				'''simple docstring'''
				a__     = self.inference_layers_num / self.inference_instances_num
				a__     = (
				    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(lowerCamelCase		)







	@add_start_docstrings_to_model_forward(lowerCamelCase		)
	def 						__a   (				self			:   Tuple , lowerCamelCase			:   str=None , lowerCamelCase			:   Dict=None , lowerCamelCase			:   str=None , lowerCamelCase			:   Tuple=None , lowerCamelCase			:   List[Any]=None , lowerCamelCase			:   List[Any]=None , lowerCamelCase			:   Dict=None , lowerCamelCase			:   Dict=None , lowerCamelCase			:   List[str]=None , lowerCamelCase			:   Optional[int]=None , lowerCamelCase			:   List[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:
							a__     = input_ids.size()
				elif inputs_embeds is not None:
							a__     = inputs_embeds.size()[:-1]
				else:
							raise ValueError("You have to specify either input_ids or inputs_embeds"		)

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

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

				# We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
				# ourselves in which case we just need to make it broadcastable to all heads.
				a__     = self.get_extended_attention_mask(lowerCamelCase , lowerCamelCase , lowerCamelCase		)

				# If a 2D ou 3D attention mask is provided for the cross-attention
				# we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
				if self.config.is_decoder and encoder_hidden_states is not None:
							a__   ,				a__   ,				a__     = encoder_hidden_states.size()
							a__     = (encoder_batch_size, encoder_sequence_length)
							if encoder_attention_mask is None:
										a__     = torch.ones(lowerCamelCase , device=lowerCamelCase		)
							a__     = self.invert_attention_mask(lowerCamelCase		)
				else:
							a__     = None

				# Prepare head mask if needed
				# 1.0 in head_mask indicate we keep the head
				# attention_probs has shape bsz x n_heads x N x N
				# input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
				# and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
				a__     = self.get_head_mask(lowerCamelCase , self.config.num_hidden_layers		)

				a__     = self.embeddings(
				    input_ids=lowerCamelCase , position_ids=lowerCamelCase , token_type_ids=lowerCamelCase , inputs_embeds=lowerCamelCase		)
				a__     = embedding_output

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

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

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

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

				return res






@add_start_docstrings(
    "Bert 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. "	,__lowerCAmelCase	,)
class       UpperCamelCase__  (		__lowerCAmelCase     ):







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




				'''simple docstring'''
				super().__init__(lowerCamelCase		)
				a__     = config.num_labels

				a__     = BertModelWithPabee(lowerCamelCase		)
				a__     = nn.Dropout(config.hidden_dropout_prob		)
				a__     = 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(lowerCamelCase		)
	def 						__a   (				self			:   Dict , lowerCamelCase			:   Dict=None , lowerCamelCase			:   List[str]=None , lowerCamelCase			:   List[Any]=None , lowerCamelCase			:   List[Any]=None , lowerCamelCase			:   int=None , lowerCamelCase			:   List[str]=None , lowerCamelCase			:   List[str]=None , ):




				'''simple docstring'''
				a__     = self.bert(
				    input_ids=lowerCamelCase , attention_mask=lowerCamelCase , token_type_ids=lowerCamelCase , position_ids=lowerCamelCase , head_mask=lowerCamelCase , inputs_embeds=lowerCamelCase , output_dropout=self.dropout , output_layers=self.classifiers , regression=self.num_labels == 1 , )

				a__     = (logits[-1],)

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

				return outputs












'''simple docstring'''


import re







def    _lowerCamelCase  (__lowerCamelCase  :     str     )   ->    bool:
			a__     = re.compile(
			    r"^(?:0|94|\+94|0{2}94)" r"7(0|1|2|4|5|6|7|8)" r"(-| |)" r"\d{7}$"     )

			return bool(re.search(__lowerCamelCase					,  __lowerCamelCase     )     )


if __name__ == "__main__":
		lowerCAmelCase_   :   Any       =					"0094702343221"

		print(is_sri_lankan_phone_number(phone))



