



"""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,
)


_UpperCAmelCase   =	logging.getLogger(__name__)
class     a		(     lowerCAmelCase_				):



  def 		lowerCamelCase__				(  self       :    Optional[Any]				,						lowerCAmelCase       :    Optional[Any]				,						lowerCAmelCase       :    List[str]				,						lowerCAmelCase       :    Dict=None				,						lowerCAmelCase       :    Union[str, Any]=None						)   ->    Optional[int]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:       Union[str, Any]   	=self.layer[current_layer](lowerCAmelCase				,						lowerCAmelCase				,						head_mask[current_layer]						)

     SCREAMING_SNAKE_CASE_:       List[str]   	=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     a		(     lowerCAmelCase_				):



  def __init__(  self       :    List[Any]				,						lowerCAmelCase       :    Dict						)   ->    Any:


     '''simple docstring'''




     super().__init__(lowerCAmelCase						)

     SCREAMING_SNAKE_CASE_:       str   	=BertEncoderWithPabee(lowerCAmelCase						)

     self.init_weights()
     SCREAMING_SNAKE_CASE_:       Optional[Any]   	=0
     SCREAMING_SNAKE_CASE_:       Any   	=0
     SCREAMING_SNAKE_CASE_:       Optional[Any]   	=0

     SCREAMING_SNAKE_CASE_:       Union[str, Any]   	=0



  def 		lowerCamelCase__				(  self       :    List[str]				,						lowerCAmelCase       :    List[str]						)   ->    List[Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:       List[Any]   	=threshold



  def 		lowerCamelCase__				(  self       :    Optional[Any]				,						lowerCAmelCase       :    str						)   ->    str:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:       List[Any]   	=patience



  def 		lowerCamelCase__				(  self       :    Any						)   ->    str:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:       Optional[int]   	=0
     SCREAMING_SNAKE_CASE_:       List[str]   	=0



  def 		lowerCamelCase__				(  self       :    Optional[Any]						)   ->    int:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:       Any   	=self.inference_layers_num / self.inference_instances_num
     SCREAMING_SNAKE_CASE_:       Union[str, Any]   	=(
         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 		lowerCamelCase__				(  self       :    Optional[Any]				,						lowerCAmelCase       :    List[Any]=None				,						lowerCAmelCase       :    Union[str, Any]=None				,						lowerCAmelCase       :    List[Any]=None				,						lowerCAmelCase       :    List[Any]=None				,						lowerCAmelCase       :    Any=None				,						lowerCAmelCase       :    str=None				,						lowerCAmelCase       :    Dict=None				,						lowerCAmelCase       :    List[str]=None				,						lowerCAmelCase       :    Any=None				,						lowerCAmelCase       :    List[Any]=None				,						lowerCAmelCase       :    Optional[int]=False				,						)   ->    Dict:


     '''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:
        SCREAMING_SNAKE_CASE_:       Tuple   	=input_ids.size()
     elif inputs_embeds is not None:
        SCREAMING_SNAKE_CASE_:       Any   	=inputs_embeds.size()[:-1]
     else:
        raise ValueError("""You have to specify either input_ids or inputs_embeds"""						)

     SCREAMING_SNAKE_CASE_:       Dict   	=input_ids.device if input_ids is not None else inputs_embeds.device

     if attention_mask is None:
        SCREAMING_SNAKE_CASE_:       Dict   	=torch.ones(lowerCAmelCase				,						device=lowerCAmelCase						)
     if token_type_ids is None:
        SCREAMING_SNAKE_CASE_:       Tuple   	=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.
     SCREAMING_SNAKE_CASE_:       torch.Tensor   	=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:
        SCREAMING_SNAKE_CASE_:       Optional[Any]   	=encoder_hidden_states.size()
        SCREAMING_SNAKE_CASE_:       Union[str, Any]   	=(encoder_batch_size, encoder_sequence_length)
        if encoder_attention_mask is None:
           SCREAMING_SNAKE_CASE_:       str   	=torch.ones(lowerCAmelCase				,						device=lowerCAmelCase						)
        SCREAMING_SNAKE_CASE_:       Optional[int]   	=self.invert_attention_mask(lowerCAmelCase						)
     else:
        SCREAMING_SNAKE_CASE_:       Any   	=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]
     SCREAMING_SNAKE_CASE_:       str   	=self.get_head_mask(lowerCAmelCase				,						self.config.num_hidden_layers						)

     SCREAMING_SNAKE_CASE_:       List[str]   	=self.embeddings(
         input_ids=lowerCAmelCase				,						position_ids=lowerCAmelCase				,						token_type_ids=lowerCAmelCase				,						inputs_embeds=lowerCAmelCase						)
     SCREAMING_SNAKE_CASE_:       Tuple   	=embedding_output

     if self.training:
        SCREAMING_SNAKE_CASE_:       Tuple   	=[]
        for i in range(self.config.num_hidden_layers						):
           SCREAMING_SNAKE_CASE_:       Dict   	=self.encoder.adaptive_forward(
               lowerCAmelCase				,						current_layer=lowerCAmelCase				,						attention_mask=lowerCAmelCase				,						head_mask=lowerCAmelCase						)

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

           SCREAMING_SNAKE_CASE_:       int   	=self.pooler(lowerCAmelCase						)
           SCREAMING_SNAKE_CASE_:       List[str]   	=output_layers[i](lowerCAmelCase						)
           if regression:
              SCREAMING_SNAKE_CASE_:       Union[str, Any]   	=logits.detach()
              if patient_result is not None:
                 SCREAMING_SNAKE_CASE_:       int   	=patient_result.detach()
              if (patient_result is not None) and torch.abs(patient_result - labels						) < self.regression_threshold:
                 patient_counter += 1
              else:
                 SCREAMING_SNAKE_CASE_:       Tuple   	=0
           else:
              SCREAMING_SNAKE_CASE_:       Optional[int]   	=logits.detach().argmax(dim=1						)
              if patient_result is not None:
                 SCREAMING_SNAKE_CASE_:       str   	=patient_result.detach().argmax(dim=1						)
              if (patient_result is not None) and torch.all(labels.eq(lowerCAmelCase						)						):
                 patient_counter += 1
              else:
                 SCREAMING_SNAKE_CASE_:       Tuple   	=0

           SCREAMING_SNAKE_CASE_:       Optional[int]   	=logits
           if patient_counter == self.patience:
              break
        SCREAMING_SNAKE_CASE_:       Any   	=[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     a		(     lowerCAmelCase_				):



  def __init__(  self       :    Optional[int]				,						lowerCAmelCase       :    Union[str, Any]						)   ->    Any:


     '''simple docstring'''




     super().__init__(lowerCAmelCase						)
     SCREAMING_SNAKE_CASE_:       Tuple   	=config.num_labels

     SCREAMING_SNAKE_CASE_:       Any   	=BertModelWithPabee(lowerCAmelCase						)
     SCREAMING_SNAKE_CASE_:       Optional[int]   	=nn.Dropout(config.hidden_dropout_prob						)
     SCREAMING_SNAKE_CASE_:       Union[str, Any]   	=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 		lowerCamelCase__				(  self       :    List[str]				,						lowerCAmelCase       :    Union[str, Any]=None				,						lowerCAmelCase       :    Dict=None				,						lowerCAmelCase       :    Dict=None				,						lowerCAmelCase       :    Any=None				,						lowerCAmelCase       :    Optional[int]=None				,						lowerCAmelCase       :    Tuple=None				,						lowerCAmelCase       :    Any=None				,						)   ->    Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:       Tuple   	=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				,						)

     SCREAMING_SNAKE_CASE_:       Union[str, Any]   	=(logits[-1],)

     if labels is not None:
        SCREAMING_SNAKE_CASE_:       Union[str, Any]   	=None
        SCREAMING_SNAKE_CASE_:       int   	=0
        for ix, logits_item in enumerate(lowerCAmelCase						):
           if self.num_labels == 1:
              #  We are doing regression
              SCREAMING_SNAKE_CASE_:       Dict   	=MSELoss()
              SCREAMING_SNAKE_CASE_:       List[str]   	=loss_fct(logits_item.view(-1						)				,						labels.view(-1						)						)
           else:
              SCREAMING_SNAKE_CASE_:       Optional[Any]   	=CrossEntropyLoss()
              SCREAMING_SNAKE_CASE_:       Optional[int]   	=loss_fct(logits_item.view(-1				,						self.num_labels						)				,						labels.view(-1						)						)
           if total_loss is None:
              SCREAMING_SNAKE_CASE_:       Tuple   	=loss
           else:
              total_loss += loss * (ix + 1)
           total_weights += ix + 1
        SCREAMING_SNAKE_CASE_:       Any   	=(total_loss / total_weights,) + outputs

     return outputs








"""simple docstring"""






from __future__ import annotations

_lowercase : Dict      						=						1.6_021E-19  # units = C






def      snake_case__   (		__lowerCamelCase				:    float							,		__lowerCamelCase				:    float							,		__lowerCamelCase				:    float							,		):
			"""simple docstring"""
			if (conductivity, electron_conc, mobility).count(0	) != 1:
						raise ValueError('''You cannot supply more or less than 2 values'''	)
			elif conductivity < 0:
						raise ValueError('''Conductivity cannot be negative'''	)
			elif electron_conc < 0:
						raise ValueError('''Electron concentration cannot be negative'''	)
			elif mobility < 0:
						raise ValueError('''mobility cannot be negative'''	)
			elif conductivity == 0:
						return (
						    "conductivity",
						    mobility * electron_conc * ELECTRON_CHARGE,
						)
			elif electron_conc == 0:
						return (
						    "electron_conc",
						    conductivity / (mobility * ELECTRON_CHARGE),
						)
			else:
						return (
						    "mobility",
						    conductivity / (electron_conc * ELECTRON_CHARGE),
						)


if __name__ == "__main__":
		import doctest

		doctest.testmod()




