





'''simple docstring'''

from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


__lowerCAmelCase							:			str				=logging.get_logger(__name__)

__lowerCAmelCase							:			List[Any]				={
    "gpt2": "https://huggingface.co/gpt2/resolve/main/config.json",
    "gpt2-medium": "https://huggingface.co/gpt2-medium/resolve/main/config.json",
    "gpt2-large": "https://huggingface.co/gpt2-large/resolve/main/config.json",
    "gpt2-xl": "https://huggingface.co/gpt2-xl/resolve/main/config.json",
    "distilgpt2": "https://huggingface.co/distilgpt2/resolve/main/config.json",
}






class      UpperCAmelCase			( __UpperCAmelCase       ):
 __lowercase     	=       """gpt2"""
 __lowercase     	=       ["""past_key_values"""]
 __lowercase     	=       {
     """hidden_size""": """n_embd""",
     """max_position_embeddings""": """n_positions""",
     """num_attention_heads""": """n_head""",
     """num_hidden_layers""": """n_layer""",
 }
 def __init__(       self   :Dict		, lowercase_   :Dict=5_02_57		, lowercase_   :Union[str, Any]=10_24		, lowercase_   :Tuple=7_68		, lowercase_   :Any=12		, lowercase_   :Dict=12		, lowercase_   :str=None		, lowercase_   :List[str]="gelu_new"		, lowercase_   :List[str]=0.1		, lowercase_   :Dict=0.1		, lowercase_   :str=0.1		, lowercase_   :int=1E-5		, lowercase_   :List[Any]=0.0_2		, lowercase_   :Tuple="cls_index"		, lowercase_   :Tuple=True		, lowercase_   :List[str]=None		, lowercase_   :Any=True		, lowercase_   :Optional[Any]=0.1		, lowercase_   :Dict=True		, lowercase_   :Dict=True		, lowercase_   :Any=5_02_56		, lowercase_   :Dict=5_02_56		, lowercase_   :Tuple=False		, lowercase_   :Union[str, Any]=False		, **lowercase_   :Dict		, )->							Union[str, Any]:
     A__       =    vocab_size
     A__       =    n_positions
     A__       =    n_embd
     A__       =    n_layer
     A__       =    n_head
     A__       =    n_inner
     A__       =    activation_function
     A__       =    resid_pdrop
     A__       =    embd_pdrop
     A__       =    attn_pdrop
     A__       =    layer_norm_epsilon
     A__       =    initializer_range
     A__       =    summary_type
     A__       =    summary_use_proj
     A__       =    summary_activation
     A__       =    summary_first_dropout
     A__       =    summary_proj_to_labels
     A__       =    scale_attn_weights
     A__       =    use_cache
     A__       =    scale_attn_by_inverse_layer_idx
     A__       =    reorder_and_upcast_attn

     A__       =    bos_token_id
     A__       =    eos_token_id

     super().__init__(bos_token_id=lowerCamelCase__		, eos_token_id=lowerCamelCase__		, **lowerCamelCase__							)






class      UpperCAmelCase			( __UpperCAmelCase       ):
 def __init__(       self   :Dict		, lowercase_   :Optional[int]		, lowercase_   :Optional[int] = "default"		, lowercase_   :Dict = None		, lowercase_   :Any = False		, )->							Optional[int]:
     super().__init__(lowerCamelCase__		, task=lowerCamelCase__		, patching_specs=lowerCamelCase__		, use_past=lowerCamelCase__							)
     if not getattr(self._config		, "pad_token_id"		, lowerCamelCase__							):
         # TODO: how to do that better?
         A__       =    0
 @property
 def   UpperCAmelCase_							(       self   :Union[str, Any]							)->							Mapping[str, Mapping[int, str]]:
     A__       =    OrderedDict({"input_ids": {0: "batch", 1: "sequence"}}							)
     if self.use_past:
         self.fill_with_past_key_values_(lowerCamelCase__		, direction="inputs"							)
         A__       =    {0: "batch", 1: "past_sequence + sequence"}
     else:
         A__       =    {0: "batch", 1: "sequence"}

     return common_inputs
 @property
 def   UpperCAmelCase_							(       self   :List[Any]							)->							int:
     return self._config.n_layer
 @property
 def   UpperCAmelCase_							(       self   :Dict							)->							int:
     return self._config.n_head
 def   UpperCAmelCase_							(       self   :List[Any]		, lowercase_   :Optional[int]		, lowercase_   :Dict = -1		, lowercase_   :str = -1		, lowercase_   :int = False		, lowercase_   :Tuple = None		, )->							Mapping[str, Any]:
     A__       =    super(lowerCamelCase__		, self							).generate_dummy_inputs(
         lowerCamelCase__		, batch_size=lowerCamelCase__		, seq_length=lowerCamelCase__		, is_pair=lowerCamelCase__		, framework=lowerCamelCase__							)

     # We need to order the input in the way they appears in the forward()
     A__       =    OrderedDict({"input_ids": common_inputs["input_ids"]}							)

     # Need to add the past_keys
     if self.use_past:
         if not is_torch_available():
             raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."							)
         else:
             import torch

             A__,			A__       =    common_inputs["input_ids"].shape
             # Not using the same length for past_key_values
             A__       =    seqlen + 2
             A__       =    (
                 batch,
                 self.num_attention_heads,
                 past_key_values_length,
                 self._config.hidden_size // self.num_attention_heads,
             )
             A__       =    [
                 (torch.zeros(lowerCamelCase__							), torch.zeros(lowerCamelCase__							)) for _ in range(self.num_layers							)
             ]

     A__       =    common_inputs["attention_mask"]
     if self.use_past:
         A__       =    ordered_inputs["attention_mask"].dtype
         A__       =    torch.cat(
             [ordered_inputs["attention_mask"], torch.ones(lowerCamelCase__		, lowerCamelCase__		, dtype=lowerCamelCase__							)]		, dim=1							)

     return ordered_inputs



 @property
 def   UpperCAmelCase_							(       self   :Tuple							)->							int:
     return 13










'''simple docstring'''

import collections

from .utils import ExplicitEnum, is_torch_available, logging


if is_torch_available():
  import torch


__lowerCAmelCase							:			Optional[int]				=logging.get_logger(__name__)






class      UpperCAmelCase			:
 def __init__(       self   :Optional[int]		, lowercase_   :Any		, lowercase_   :Any=21		, lowercase_   :Any=[]		, lowercase_   :Dict=None							)->							Tuple:
     A__       =    model
     A__       =    trace_batch_nums
     A__       =    abort_after_batch_num

     # keep a LIFO buffer of frames to dump as soon as inf/nan is encountered to give context to the problem emergence
     A__       =    collections.deque([]		, lowercase_							)
     A__       =    []
     A__       =    0
     A__       =    0
     A__       =    False
     A__       =    "                 "

     self.analyse_model()

     self.register_forward_hook()
 def   UpperCAmelCase_							(       self   :Any		, lowercase_   :Any=None							)->							Optional[Any]:
     if frame is not None:
         self.expand_frame(lowercase_							)
     self.frames.append("\n".join(self.frame							)							)
     A__       =    []  # start a new frame
 def   UpperCAmelCase_							(       self   :Union[str, Any]		, lowercase_   :Dict							)->							List[str]:
     self.frame.append(lowercase_							)
 def   UpperCAmelCase_							(       self   :int							)->							Dict:
     print("\n".join(self.frames							)							)
     A__       =    []
 def   UpperCAmelCase_							(       self   :str							)->							Union[str, Any]:
     A__       =    []
 def   UpperCAmelCase_							(       self   :List[str]							)->							Optional[Any]:
     print(F"\nDetected inf/nan during batch_number={self.batch_number}"							)
     print(F"Last {len(self.frames							)} forward frames:"							)
     print(F"{'abs min':8} {'abs max':8} metadata"							)
     print("\n".join(self.frames							)							)
     print("\n\n"							)
     A__       =    []
 def   UpperCAmelCase_							(       self   :Any							)->							Optional[Any]:
     # extract the fully qualified module names, to be able to report at run time. e.g.:
     # encoder.block.2.layer.0.SelfAttention.o
     #
     # for shared weights only the first shared module name will be registered
     A__       =    {m: name for name, m in self.model.named_modules()}
     # self.longest_module_name = max(len(v) for v in self.module_names.values())
 def   UpperCAmelCase_							(       self   :Tuple		, lowercase_   :Dict		, lowercase_   :Any							)->							str:
     if torch.is_tensor(lowercase_							):
         self.expand_frame(get_abs_min_max(lowercase_		, lowercase_							)							)
         if detect_overflow(lowercase_		, lowercase_							):
             A__       =    True
     elif var is None:
         self.expand_frame(F"{'None':>17} {ctx}"							)
     else:
         self.expand_frame(F"{'not a tensor':>17} {ctx}"							)
 def   UpperCAmelCase_							(       self   :Union[str, Any]							)->							str:
     self.expand_frame(F"\n\n{self.prefix} *** Starting batch number={self.batch_number} ***"							)
     self.expand_frame(F"{'abs min':8} {'abs max':8} metadata"							)
 def   UpperCAmelCase_							(       self   :int							)->							int:
     self.expand_frame(F"{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n"							)
 def   UpperCAmelCase_							(       self   :Optional[int]		, lowercase_   :Dict		, lowercase_   :Dict		, lowercase_   :str							)->							int:
     self.expand_frame(F"{self.prefix} {self.module_names[module]} {module.__class__.__name__}"							)

     # params
     for name, p in module.named_parameters(recurse=lowercase_							):
         self.analyse_variable(lowercase_		, lowercase_							)

     # inputs
     if isinstance(lowercase_		, lowercase_							):
         for i, x in enumerate(lowercase_							):
             self.analyse_variable(lowercase_		, F"input[{i}]"							)
     else:
         self.analyse_variable(lowercase_		, "input"							)

     # outputs
     if isinstance(lowercase_		, lowercase_							):
         for i, x in enumerate(lowercase_							):
             # possibly a tuple of tuples
             if isinstance(lowercase_		, lowercase_							):
                 for j, y in enumerate(lowercase_							):
                     self.analyse_variable(lowercase_		, F"output[{i}][{j}]"							)
             else:
                 self.analyse_variable(lowercase_		, F"output[{i}]"							)
     else:
         self.analyse_variable(lowercase_		, "output"							)

     self.save_frame()
 def   UpperCAmelCase_							(       self   :Any							)->							int:
     self.model.apply(self._register_forward_hook							)
 def   UpperCAmelCase_							(       self   :Tuple		, lowercase_   :Optional[int]							)->							Tuple:
     module.register_forward_hook(self.forward_hook							)



 def   UpperCAmelCase_							(       self   :List[str]		, lowercase_   :int		, lowercase_   :Optional[Any]		, lowercase_   :Dict							)->							Union[str, Any]:
     # - input is a tuple of packed inputs (could be non-Tensors)
     # - output could be a Tensor or a tuple of Tensors and non-Tensors

     A__       =    False

     A__       =    True if self.batch_number in self.trace_batch_nums else False
     if trace_mode:
         self.reset_saved_frames()

     if self.total_calls == 0:
         self.batch_start_frame()
     self.total_calls += 1

     # count batch numbers - the very first forward hook of the batch will be called when the
     # batch completes - i.e. it gets called very last - we know this batch has finished
     if module == self.model:
         self.batch_number += 1
         A__       =    True

     self.create_frame(lowercase_		, lowercase_		, lowercase_							)

     # if last_frame_of_batch:
     #     self.batch_end_frame()

     if trace_mode:
         self.trace_frames()

     if last_frame_of_batch:
         self.batch_start_frame()

     if self.detected_overflow and not trace_mode:
         self.dump_saved_frames()

         # now we can abort, as it's pointless to continue running
         raise ValueError(
             "DebugUnderflowOverflow: inf/nan detected, aborting as there is no point running further. "
             "Please scroll up above this traceback to see the activation values prior to this event."							)

     # abort after certain batch if requested to do so
     if self.abort_after_batch_num is not None and self.batch_number > self.abort_after_batch_num:
         raise ValueError(
             F"DebugUnderflowOverflow: aborting after {self.batch_number} batches due to"
             F" `abort_after_batch_num={self.abort_after_batch_num}` arg"							)





def 		UpperCamelCase       (							_lowerCamelCase      :      Dict		, _lowerCamelCase      :      int ):
    A__       =    var.abs()
    return F"{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}"





def 		UpperCamelCase       (							_lowerCamelCase      :      Tuple		, _lowerCamelCase      :      Optional[int] ):
    A__       =    False
    if torch.isnan(_lowerCamelCase ).any().item():
        A__       =    True
        print(F"{ctx} has nans" )
    if torch.isinf(_lowerCamelCase ).any().item():
        A__       =    True
        print(F"{ctx} has infs" )

    # if needed to monitor large elements can enable the following
    if 0:  # and detected:
        A__       =    var[torch.ge(var.abs()		, 1_00 )]
        if naaa.numel() > 0:
            print(F"{ctx}:  n100={naaa.numel()}" )
        A__       =    var[torch.ge(var.abs()		, 10_00 )]
        if naaaa.numel() > 0:
            print(F"{ctx}: n1000={naaaa.numel()}" )
        A__       =    var[torch.ge(var.abs()		, 1_00_00 )]
        if naaaaa.numel() > 0:
            print(F"{ctx}: n10000={naaaaa.numel()}" )

    if 0:
        print(F"min={var.min():9.2e} max={var.max():9.2e}" )

    if 0:
        print(F"min={var.min():9.2e} max={var.max():9.2e} var={var.var():9.2e} mean={var.mean():9.2e} ({ctx})" )

    return detected






class      UpperCAmelCase			( UpperCamelCase__       ):
 __lowercase     	=       """underflow_overflow"""
 __lowercase     	=       """tpu_metrics_debug"""



