o �J�hk2�@sfddlZddlmZmZmZe�rddlZe�e�ZGdd�d�Z dd�Z dd �ZGd d�de�ZdS)�N�)�ExplicitEnum�is_torch_available�loggingc@s�eZdZdZdgdfdd�Zd dd�Zdd �Zd d�Zdd �Zdd�Z dd�Z dd�Zdd�Zdd�Z dd�Zdd�Zdd�Zdd�ZdS)!�DebugUnderflowOverflowa� This debug class helps detect and understand where the model starts getting very large or very small, and more importantly `nan` or `inf` weight and activation elements. There are 2 working modes: 1. Underflow/overflow detection (default) 2. Specific batch absolute min/max tracing without detection Mode 1: Underflow/overflow detection To activate the underflow/overflow detection, initialize the object with the model : ```python debug_overflow = DebugUnderflowOverflow(model) ``` then run the training as normal and if `nan` or `inf` gets detected in at least one of the weight, input or output elements this module will throw an exception and will print `max_frames_to_save` frames that lead to this event, each frame reporting 1. the fully qualified module name plus the class name whose `forward` was run 2. the absolute min and max value of all elements for each module weights, and the inputs and output For example, here is the header and the last few frames in detection report for `google/mt5-small` run in fp16 mixed precision : ``` Detected inf/nan during batch_number=0 Last 21 forward frames: abs min abs max metadata [...] encoder.block.2.layer.1.DenseReluDense.wi_0 Linear 2.17e-07 4.50e+00 weight 1.79e-06 4.65e+00 input[0] 2.68e-06 3.70e+01 output encoder.block.2.layer.1.DenseReluDense.wi_1 Linear 8.08e-07 2.66e+01 weight 1.79e-06 4.65e+00 input[0] 1.27e-04 2.37e+02 output encoder.block.2.layer.1.DenseReluDense.wo Linear 1.01e-06 6.44e+00 weight 0.00e+00 9.74e+03 input[0] 3.18e-04 6.27e+04 output encoder.block.2.layer.1.DenseReluDense T5DenseGatedGeluDense 1.79e-06 4.65e+00 input[0] 3.18e-04 6.27e+04 output encoder.block.2.layer.1.dropout Dropout 3.18e-04 6.27e+04 input[0] 0.00e+00 inf output ``` You can see here, that `T5DenseGatedGeluDense.forward` resulted in output activations, whose absolute max value was around 62.7K, which is very close to fp16's top limit of 64K. In the next frame we have `Dropout` which renormalizes the weights, after it zeroed some of the elements, which pushes the absolute max value to more than 64K, and we get an overlow. As you can see it's the previous frames that we need to look into when the numbers start going into very large for fp16 numbers. The tracking is done in a forward hook, which gets invoked immediately after `forward` has completed. By default the last 21 frames are printed. You can change the default to adjust for your needs. For example : ```python debug_overflow = DebugUnderflowOverflow(model, max_frames_to_save=100) ``` To validate that you have set up this debugging feature correctly, and you intend to use it in a training that may take hours to complete, first run it with normal tracing enabled for one of a few batches as explained in the next section. Mode 2. Specific batch absolute min/max tracing without detection The second work mode is per-batch tracing with the underflow/overflow detection feature turned off. Let's say you want to watch the absolute min and max values for all the ingredients of each `forward` call of a given batch, and only do that for batches 1 and 3. Then you instantiate this class as : ```python debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1, 3]) ``` And now full batches 1 and 3 will be traced using the same format as explained above. Batches are 0-indexed. This is helpful if you know that the program starts misbehaving after a certain batch number, so you can fast-forward right to that area. Early stopping: You can also specify the batch number after which to stop the training, with : ```python debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1, 3], abort_after_batch_num=3) ``` This feature is mainly useful in the tracing mode, but you can use it for any mode. **Performance**: As this module measures absolute `min`/``max` of each weight of the model on every forward it'll slow the training down. Therefore remember to turn it off once the debugging needs have been met. Args: model (`nn.Module`): The model to debug. max_frames_to_save (`int`, *optional*, defaults to 21): How many frames back to record trace_batch_nums(`List[int]`, *optional*, defaults to `[]`): Which batch numbers to trace (turns detection off) abort_after_batch_num (`int``, *optional*): Whether to abort after a certain batch number has finished �NcCsR||_||_||_t�g|�|_g|_d|_d|_d|_ d|_ |��|��dS)NrFz ) �model�trace_batch_nums�abort_after_batch_num�collections�deque�frames�frame�batch_number�total_calls�detected_overflow�prefix� analyse_model�register_forward_hook)�selfrZmax_frames_to_saver r �r�VC:\pinokio\api\whisper-webui.git\app\env\lib\site-packages\transformers\debug_utils.py�__init__�szDebugUnderflowOverflow.__init__cCs0|dur |�|�|j�d�|j��g|_dS�N� )�expand_framer �append�joinr)rrrrr� save_frame�s z!DebugUnderflowOverflow.save_framecCs|j�|�dS�N)rr)r�linerrrr��z#DebugUnderflowOverflow.expand_framecCstd�|j��g|_dSr)�printrr �rrrr�trace_frames�s z#DebugUnderflowOverflow.trace_framescCs g|_dSr)r r#rrr�reset_saved_frames�s z)DebugUnderflowOverflow.reset_saved_framescCs`td|j��tdt|j��d��tdd�ddd�d��td �|j��td �g|_dS)Nz& Detected inf/nan during batch_number=zLast z forward frames:�abs min�8� �abs max� metadatar� )r"r�lenr rr#rrr�dump_saved_frames�s z(DebugUnderflowOverflow.dump_saved_framescCsdd�|j��D�|_dS)NcSsi|]\}}||�qSrr)�.0�name�mrrr� <dictcomp>�sz8DebugUnderflowOverflow.analyse_model.<locals>.<dictcomp>)r� named_modules�module_namesr#rrrr�sz$DebugUnderflowOverflow.analyse_modelcCsnt�|�r|�t||��t||�rd|_dSdS|dur*|�dd�d|��dS|�dd�d|��dS)NT�Nonez>17r(znot a tensor)�torch� is_tensorr�get_abs_min_max�detect_overflowr)r�var�ctxrrr�analyse_variable�s �z'DebugUnderflowOverflow.analyse_variablecCs:|�d|j�d|j�d��|�dd�ddd�d��dS) Nr+z *** Starting batch number=z ***r&r'r(r)r*�rrrr#rrr�batch_start_frame�sz(DebugUnderflowOverflow.batch_start_framecCs"|�|j�d|jd�d��dS)Nz *** Finished batch number=rz *** r<r#rrr�batch_end_frame�s"z&DebugUnderflowOverflow.batch_end_framec Cs|�|j�d|j|�d|jj��|jdd�D] \}}|�||�qt|t�r=t |�D]\}}|�|d|�d��q-n|�|d�t|t�rxt |�D]*\}}t|t�rlt |�D]\}} |�| d|�d|�d��qYqL|�|d|�d��qLn|�|d �|� �dS) Nr(F)�recursezinput[�]�inputzoutput[z][�output)rrr3� __class__�__name__�named_parametersr;� isinstance�tuple� enumerater) r�modulerArBr/�p�i�x�j�yrrr�create_frame�s$& � ��z#DebugUnderflowOverflow.create_framecCs|j�|j�dSr)r�apply�_register_forward_hookr#rrrr�sz,DebugUnderflowOverflow.register_forward_hookcCs|�|j�dSr)r�forward_hook)rrIrrrrQ�r!z-DebugUnderflowOverflow._register_forward_hookcCs�d}|j|jvr dnd}|r|��|jdkr|��|jd7_||jkr0|jd7_d}|�|||�|r=|��|rC|��|jrP|sP|� �t d��|jdurh|j|jkrjt d|j�d|j�d��dSdS) NFTrrz�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.z'DebugUnderflowOverflow: aborting after z' batches due to `abort_after_batch_num=z` arg)rr r%rr=rrOr$rr-� ValueErrorr )rrIrArBZlast_frame_of_batchZ trace_moderrrrR�s6 � ��z#DebugUnderflowOverflow.forward_hookr)rD� __module__�__qualname__�__doc__rrrr$r%r-rr;r=r>rOrrQrRrrrrrs u rcCs(|��}|��d�d|��d�d|��S)Nz8.2er()�abs�min�max)r9r:Zabs_varrrrr7%s r7cCsVd}t�|��rd}t|�d��t�|��r&d}t|�d�� |S)a& Report whether the tensor contains any `nan` or `inf` entries. This is useful for detecting overflows/underflows and best to call right after the function that did some math that modified the tensor in question. This function contains a few other helper features that you can enable and tweak directly if you want to track various other things. Args: var: the tensor variable to check ctx: the message to print as a context Return: `True` if `inf` or `nan` was detected, `False` otherwise FTz has nansz has infs) r5�isnan�any�itemr"�isinf�gerW�numelrXrYr9�mean)r9r:�detectedZn100Zn1000Zn10000rrrr8*sr8c@seZdZdZdZdS)�DebugOptionZunderflow_overflow�tpu_metrics_debugN)rDrTrUZUNDERFLOW_OVERFLOWZTPU_METRICS_DEBUGrrrrrbXsrb) r�utilsrrrr5� get_loggerrD�loggerrr7r8rbrrrr�<module>s .