

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_         =      logging.getLogger(__name__)






class _UpperCamelCase							(							UpperCAmelCase__				):
			'''simple docstring'''







			def 							__UpperCamelCase	(     self							:	Union[str, Any] , a							:	str , a							:	List[str] , a							:	int=None , a							:	Tuple=None		)							->    int:

				"""simple docstring"""

				if current_layer == 0:
					SCREAMING_SNAKE_CASE				: Union[str, Any]			       =    self.embedding_hidden_mapping_in(snake_case_		)
				else:
					SCREAMING_SNAKE_CASE				: List[str]			       =    hidden_states[0]

				SCREAMING_SNAKE_CASE				: Tuple			       =    int(self.config.num_hidden_layers / self.config.num_hidden_groups		)

				# Index of the hidden group
				SCREAMING_SNAKE_CASE				: Optional[Any]			       =    int(current_layer / (self.config.num_hidden_layers / self.config.num_hidden_groups)		)

				SCREAMING_SNAKE_CASE				: List[Any]			       =    self.albert_layer_groups[group_idx](
				    snake_case_ , snake_case_ , head_mask[group_idx * layers_per_group : (group_idx + 1) * layers_per_group] , )
				SCREAMING_SNAKE_CASE				: str			       =    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.'							,		UpperCAmelCase__							,		)
class _UpperCamelCase							(							UpperCAmelCase__				):
			'''simple docstring'''







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

				"""simple docstring"""

				super().__init__(snake_case_		)

				SCREAMING_SNAKE_CASE				: Tuple			       =    AlbertTransformerWithPabee(snake_case_		)

				self.init_weights()
				SCREAMING_SNAKE_CASE				: str			       =    0
				SCREAMING_SNAKE_CASE				: str			       =    0
				SCREAMING_SNAKE_CASE				: int			       =    0

				SCREAMING_SNAKE_CASE				: Optional[Any]			       =    0
			def 							__UpperCamelCase	(     self							:	Any , a							:	Any		)							->    int:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: List[str]			       =    threshold
			def 							__UpperCamelCase	(     self							:	Optional[Any] , a							:	Union[str, Any]		)							->    Tuple:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: Any			       =    patience
			def 							__UpperCamelCase	(     self							:	Optional[Any]		)							->    Optional[Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: Optional[int]			       =    0
				SCREAMING_SNAKE_CASE				: Union[str, Any]			       =    0
			def 							__UpperCamelCase	(     self							:	Dict		)							->    Dict:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: Tuple			       =    self.inference_layers_num / self.inference_instances_num
				SCREAMING_SNAKE_CASE				: List[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(snake_case_		)






			@add_start_docstrings_to_model_forward(snake_case_		)
			def 							__UpperCamelCase	(     self							:	Union[str, Any] , a							:	Tuple=None , a							:	Tuple=None , a							:	Tuple=None , a							:	Optional[Any]=None , a							:	Union[str, Any]=None , a							:	Any=None , a							:	Any=None , a							:	Optional[Any]=None , a							:	str=False , )							->    Optional[Any]:

				"""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				: Union[str, Any]			       =    inputs_embeds.size()[:-1]
				else:
					raise ValueError("You have to specify either input_ids or inputs_embeds"		)

				SCREAMING_SNAKE_CASE				: Tuple			       =    input_ids.device if input_ids is not None else inputs_embeds.device

				if attention_mask is None:
					SCREAMING_SNAKE_CASE				: Tuple			       =    torch.ones(snake_case_ , device=snake_case_		)
				if token_type_ids is None:
					SCREAMING_SNAKE_CASE				: Optional[int]			       =    torch.zeros(snake_case_ , dtype=torch.long , device=snake_case_		)

				SCREAMING_SNAKE_CASE				: List[Any]			       =    attention_mask.unsqueeze(1		).unsqueeze(2		)
				SCREAMING_SNAKE_CASE				: Union[str, Any]			       =    extended_attention_mask.to(dtype=self.dtype		)  # fp16 compatibility
				SCREAMING_SNAKE_CASE				: Tuple			       =    (1.0 - extended_attention_mask) * -1_0000.0
				SCREAMING_SNAKE_CASE				: Union[str, Any]			       =    self.get_head_mask(snake_case_ , self.config.num_hidden_layers		)

				SCREAMING_SNAKE_CASE				: Union[str, Any]			       =    self.embeddings(
				    snake_case_ , position_ids=snake_case_ , token_type_ids=snake_case_ , inputs_embeds=snake_case_		)
				SCREAMING_SNAKE_CASE				: List[str]			       =    embedding_output

				if self.training:
					SCREAMING_SNAKE_CASE				: Optional[Any]			       =    []
					for i in range(self.config.num_hidden_layers		):
						SCREAMING_SNAKE_CASE				: int			       =    self.encoder.adaptive_forward(
						    snake_case_ , current_layer=snake_case_ , attention_mask=snake_case_ , head_mask=snake_case_ , )

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

						SCREAMING_SNAKE_CASE				: Optional[Any]			       =    self.pooler_activation(self.pooler(encoder_outputs[0][:, 0]		)		)
						SCREAMING_SNAKE_CASE				: int			       =    output_layers[i](snake_case_		)
						if regression:
							SCREAMING_SNAKE_CASE				: Optional[Any]			       =    logits.detach()
							if patient_result is not None:
								SCREAMING_SNAKE_CASE				: Optional[Any]			       =    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				: List[str]			       =    0
						else:
							SCREAMING_SNAKE_CASE				: List[Any]			       =    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(snake_case_		)		):
								patient_counter += 1
							else:
								SCREAMING_SNAKE_CASE				: Optional[int]			       =    0

						SCREAMING_SNAKE_CASE				: int			       =    logits
						if patient_counter == self.patience:
							break
					SCREAMING_SNAKE_CASE				: List[str]			       =    [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. '							,		UpperCAmelCase__							,		)
class _UpperCamelCase							(							UpperCAmelCase__				):
			'''simple docstring'''







			def __init__(     self							:	Tuple , a							:	int		)							->    str:

				"""simple docstring"""

				super().__init__(snake_case_		)
				SCREAMING_SNAKE_CASE				: int			       =    config.num_labels

				SCREAMING_SNAKE_CASE				: Optional[Any]			       =    AlbertModelWithPabee(snake_case_		)
				SCREAMING_SNAKE_CASE				: List[str]			       =    nn.Dropout(config.classifier_dropout_prob		)
				SCREAMING_SNAKE_CASE				: int			       =    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(snake_case_		)
			def 							__UpperCamelCase	(     self							:	Union[str, Any] , a							:	List[str]=None , a							:	Dict=None , a							:	str=None , a							:	List[str]=None , a							:	str=None , a							:	List[str]=None , a							:	List[Any]=None , )							->    Optional[int]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: List[Any]			       =    self.albert(
				    input_ids=snake_case_ , attention_mask=snake_case_ , token_type_ids=snake_case_ , position_ids=snake_case_ , head_mask=snake_case_ , inputs_embeds=snake_case_ , 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				: Tuple			       =    None
					SCREAMING_SNAKE_CASE				: str			       =    0
					for ix, logits_item in enumerate(snake_case_		):
						if self.num_labels == 1:
							#  We are doing regression
							SCREAMING_SNAKE_CASE				: List[str]			       =    MSELoss()
							SCREAMING_SNAKE_CASE				: Dict			       =    loss_fct(logits_item.view(-1		) , labels.view(-1		)		)
						else:
							SCREAMING_SNAKE_CASE				: Any			       =    CrossEntropyLoss()
							SCREAMING_SNAKE_CASE				: List[str]			       =    loss_fct(logits_item.view(-1 , self.num_labels		) , labels.view(-1		)		)
						if total_loss is None:
							SCREAMING_SNAKE_CASE				: List[str]			       =    loss
						else:
							total_loss += loss * (ix + 1)
						total_weights += ix + 1
					SCREAMING_SNAKE_CASE				: Tuple			       =    (total_loss / total_weights,) + outputs

				return outputs


from __future__ import annotations






class _UpperCamelCase							:
			'''simple docstring'''







			def __init__(     self							:	List[Any] , a							:	int		)							->    None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: List[str]			       =    vertices
				SCREAMING_SNAKE_CASE				: Tuple			       =    [[0] * vertices for _ in range(a		)]
			def 							__UpperCamelCase	(     self							:	Dict , a							:	list[int]		)							->    None:

				"""simple docstring"""

				print("Vertex \t Distance from Source"		)
				for vertex in range(self.vertices		):
					print(a , "\t\t" , distances_from_source[vertex]		)
			def 							__UpperCamelCase	(     self							:	Tuple , a							:	list[int] , a							:	list[bool]		)							->    int:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: Dict			       =    1e7
				SCREAMING_SNAKE_CASE				: int			       =    0

				# Search not nearest vertex not in the shortest path tree
				for vertex in range(self.vertices		):
					if distances_from_source[vertex] < minimum and visited[vertex] is False:
						SCREAMING_SNAKE_CASE				: Optional[int]			       =    distances_from_source[vertex]
						SCREAMING_SNAKE_CASE				: Optional[Any]			       =    vertex
				return min_index






			def 							__UpperCamelCase	(     self							:	Any , a							:	int		)							->    None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: List[str]			       =    [int(1e7		)] * self.vertices  # distances from the source
				SCREAMING_SNAKE_CASE				: Tuple			       =    0
				SCREAMING_SNAKE_CASE				: List[Any]			       =    [False] * self.vertices

				for _ in range(self.vertices		):
					SCREAMING_SNAKE_CASE				: Union[str, Any]			       =    self.minimum_distance(a , a		)
					SCREAMING_SNAKE_CASE				: List[str]			       =    True

					# Update dist value of the adjacent vertices
					# of the picked vertex only if the current
					# distance is greater than new distance and
					# the vertex in not in the shortest path tree
					for v in range(self.vertices		):
						if (
						    self.graph[u][v] > 0
						    and visited[v] is False
						    and distances[v] > distances[u] + self.graph[u][v]
						):
							SCREAMING_SNAKE_CASE				: int			       =    distances[u] + self.graph[u][v]

				self.print_solution(a		)


if __name__ == "__main__":
			a_         =      Graph(9)
			a_         =      [
			    [0, 4, 0, 0, 0, 0, 0, 8, 0],
			    [4, 0, 8, 0, 0, 0, 0, 11, 0],
			    [0, 8, 0, 7, 0, 4, 0, 0, 2],
			    [0, 0, 7, 0, 9, 14, 0, 0, 0],
			    [0, 0, 0, 9, 0, 10, 0, 0, 0],
			    [0, 0, 4, 14, 10, 0, 2, 0, 0],
			    [0, 0, 0, 0, 0, 2, 0, 1, 6],
			    [8, 11, 0, 0, 0, 0, 1, 0, 7],
			    [0, 0, 2, 0, 0, 0, 6, 7, 0],
			]
			graph.dijkstra(0)