


'''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.albert.modeling_albert import (
    ALBERT_INPUTS_DOCSTRING,
    ALBERT_START_DOCSTRING,
    AlbertModel,
    AlbertPreTrainedModel,
    AlbertTransformer,
)


a__    :   Tuple								=			logging.getLogger(__name__)
class    lowercase_	(       a__  ):


    def   __a				(	self    ,   a    ,   a    ,   a=None    ,   a=None       ):
          if current_layer == 0:
                UpperCamelCase__      =							self.embedding_hidden_mapping_in(a       )
          else:
                UpperCamelCase__      =							hidden_states[0]

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

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

          UpperCamelCase__      =							self.albert_layer_groups[group_idx](
              a    ,   a    ,   head_mask[group_idx * layers_per_group : (group_idx + 1) * layers_per_group]    ,   )
          UpperCamelCase__      =							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.'    ,		a__    ,		)
class    lowercase_	(       a__  ):


    def __init__(	self    ,   a       ):
          super().__init__(a       )

          UpperCamelCase__      =							AlbertTransformerWithPabee(a       )

          self.init_weights()
          UpperCamelCase__      =							0
          UpperCamelCase__      =							0
          UpperCamelCase__      =							0

          UpperCamelCase__      =							0


    def   __a				(	self    ,   a       ):
          UpperCamelCase__      =							threshold


    def   __a				(	self    ,   a       ):
          UpperCamelCase__      =							patience


    def   __a				(	self       ):
          UpperCamelCase__      =							0
          UpperCamelCase__      =							0


    def   __a				(	self       ):
          UpperCamelCase__      =							self.inference_layers_num / self.inference_instances_num
          UpperCamelCase__      =							(
              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(a       )


    @add_start_docstrings_to_model_forward(a       )
    def   __a				(	self    ,   a=None    ,   a=None    ,   a=None    ,   a=None    ,   a=None    ,   a=None    ,   a=None    ,   a=None    ,   a=False    ,   ):

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

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

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

          UpperCamelCase__      =							attention_mask.unsqueeze(1       ).unsqueeze(2       )
          UpperCamelCase__      =							extended_attention_mask.to(dtype=self.dtype       )  # fp16 compatibility
          UpperCamelCase__      =							(1.0 - extended_attention_mask) * -1_0000.0
          UpperCamelCase__      =							self.get_head_mask(a    ,   self.config.num_hidden_layers       )

          UpperCamelCase__      =							self.embeddings(
              a    ,   position_ids=a    ,   token_type_ids=a    ,   inputs_embeds=a       )
          UpperCamelCase__      =							embedding_output

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

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

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

                      UpperCamelCase__      =							logits
                      if patient_counter == self.patience:
                            break
                UpperCamelCase__      =							[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. '    ,		a__    ,		)
class    lowercase_	(       a__  ):


    def __init__(	self    ,   a       ):
          super().__init__(a       )
          UpperCamelCase__      =							config.num_labels

          UpperCamelCase__      =							AlbertModelWithPabee(a       )
          UpperCamelCase__      =							nn.Dropout(config.classifier_dropout_prob       )
          UpperCamelCase__      =							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(a       )
    def   __a				(	self    ,   a=None    ,   a=None    ,   a=None    ,   a=None    ,   a=None    ,   a=None    ,   a=None    ,   ):
          UpperCamelCase__      =							self.albert(
              input_ids=a    ,   attention_mask=a    ,   token_type_ids=a    ,   position_ids=a    ,   head_mask=a    ,   inputs_embeds=a    ,   output_dropout=self.dropout    ,   output_layers=self.classifiers    ,   regression=self.num_labels == 1    ,   )

          UpperCamelCase__      =							(logits[-1],)

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

          return outputs









'''simple docstring'''







from __future__ import annotations

# Define the Gravitational Constant G and the function
a__    :   Optional[int]								=			6.67_43E-11  # unit of G : m^3 * kg^-1 * s^-2







def _UpperCamelCase			(	__A ,     __A ,     __A ,     __A       )				->						dict[str, float]:


      '''simple docstring'''



      UpperCamelCase__      =							mass_a * mass_a

      if (force, mass_a, mass_a, distance).count(0       ) != 1:
            raise ValueError("One and only one argument must be 0"       )
      if force < 0:
            raise ValueError("Gravitational force can not be negative"       )
      if distance < 0:
            raise ValueError("Distance can not be negative"       )
      if mass_a < 0 or mass_a < 0:
            raise ValueError("Mass can not be negative"       )
      if force == 0:
            UpperCamelCase__      =							GRAVITATIONAL_CONSTANT * product_of_mass / (distance**2)
            return {"force": force}
      elif mass_a == 0:
            UpperCamelCase__      =							(force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
            return {"mass_1": mass_a}
      elif mass_a == 0:
            UpperCamelCase__      =							(force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
            return {"mass_2": mass_a}
      elif distance == 0:
            UpperCamelCase__      =							(GRAVITATIONAL_CONSTANT * product_of_mass / (force)) ** 0.5
            return {"distance": distance}
      raise ValueError("One and only one argument must be 0"       )


# Run doctest
if __name__ == "__main__":
  import doctest

  doctest.testmod()





