^j1NdZddlmZddlZddlmZddlmZddlm Z ddl m Z dd l m Z mZe r dd lmZd d lmZiZeed GddZGddZedZ d ddZ ddZdddZej4Zd dZddddZy)!z Contains the logic for automatic additional output capture with our forward decorators. This mostly describe the hooks used and the logic to make capture thread/context safe. ) annotationsN) ContextVar) dataclasswraps) TYPE_CHECKING)is_torchdynamo_compilingrequires)nnPreTrainedModel)torch)backendscTeZdZUdZded<dZded<dZded <dZded <d Zd ed <y)OutputRecordera Configuration for recording outputs from a model via hooks. Attributes: target_class (Type): The class (e.g., nn.Module) to which the hook will be attached. index (Optional[int]): If the output is a tuple/list, optionally record only at a specific index. layer_name (Optional[str]): Name of the submodule to target (if needed), e.g., "transformer.layer.3.attn". class_name (Optional[str]): Name of the class to which the hook will be attached. Could be the suffix of class name in some cases. capture_initial_hidden_state (bool): Whether to prepend the first module's input as the initial hidden state. ztype[nn.Module] target_classrintindexN str | None layer_name class_nameTboolcapture_initial_hidden_state) __name__ __module__ __qualname____doc____annotations__rrrrn/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/utils/output_capturing.pyrr's7 "!E3N!J !!J !)- $-r"rc(eZdZdZdZdZdZdZy)CompileableContextVara Convenience wrapper around a ContextVar for usage with `torch.compile`. This behaves exactly as a `ContextVar`, except when compilation is triggered in which case it behaves as a simple global variable. This is useful as `torch.compile` cannot trace the `get` method of `ContextVar`. This however means that the access to the underlying variable is not thread-safe when compilation is triggered. cDt|d|_d|_d|_y)N)defaultF)r context_var global_var compiling)selfnames r#__init__zCompileableContextVar.__init__Ds%dD9r"cf|jr |jS|jjSN)r*r)r(get)r+s r#r0zCompileableContextVar.getIs( >>?? "##'') )r"cjtr||_d|_y|jj |S)NT)r r)r*r(set)r+values r#r2zCompileableContextVar.setPs0 # %#DO!DN##''. .r"ct|js|d|_d|_y|jj|y)NF)r*r)r(reset)r+tokens r#r5zCompileableContextVar.resetXs/ >>U]"DO"DN    " "5 )r"N)rrrrr-r0r2r5r!r"r#r%r%<s */*r"r%output_collectorTc:fd}|j|y)zaInstall the forward hook needed to capture the output described by `key` and `index` in `module`.c:tj}||jvryr-dk(r(t|dk(r|j |dt |t s|j |y||j |yy)N hidden_statesr)_active_collectorr0keyslenappend isinstancetuple)moduleargsoutputcollected_outputsrrkeys r#output_capturing_hookz;install_output_capuring_hook..output_capturing_hookis-113  $3D3I3I3K(K  'C?,BsK\]`KaGbfgGg c " ) )$q' 2&%( c " ) )& 1 E] & c " ) )&- 8'r"N)register_forward_hook)rArErrrFs ``` r#install_output_capuring_hookrHds 9   !67r"cddlm}|jD]6\}}t||st ||d||%t ||d|8|D]\}}|j duxrt||j }|jduxr|j|j} |s| s\|j-|jjd} d| zdz} | |dzv} | st|||j|jy)a Recursively install all output capturing hooks on all submodules of `parent_module`. Note that we need to use this recursive approach instead of simply iterating over all modules, because we want to respect the `capture_tasks` of all individual submodels (`PreTrainedModel` instances) in the graph. That is, once we reach a submodel in the graph, its children should use this submodel's `capture_tasks`, but other parts of the graph should not. r r.)prefixN)modeling_utilsrnamed_childrenr?recursively_install_hooks"install_all_output_capturing_hooksrrendswithrstriprHrr) parent_module module_name capture_tasksrr,rArEspecsmatch_target_classmatch_class_nametarget_layer_namematchess r#rNrNzs)1&446W f&/2 %f Qtf.E} U /v Qtf>U V W$n U"//t;m =Z_ZlZl@m ++47bKd|vrdnd}t |tsdn|}t |ts|nd} t| ||}|j||fe||nd}t|||t|ddy) z Install the output recording hooks on all the modules in `model`. This will take care of correctly dispatching the `_can_record_outputs` property of each individual submodels in case of composite models. r:rr N)rrr!_output_capturing_hooks_installedT) _CAN_RECORD_REGISTRYr0str __class__itemsr?listrr>rNsetattr) modelrK capture_flagsrTrE layer_specsrUrrrs r#rOrOs ),,S-ABHbMM)//1 /[+t,&-K  /Ee^4,3)3E3)?TU ,6uc,Bu &LZde  #u .  / /)VrFeV]; E6=r"ct|ddryt5t|ddr dddyt|dddy#1swYyxYw)z Check if the model already has output capturing hooks installed, and install them if it is not already the case. Note that this is thread-safe, in case 2 (or more) threads want to install them concurrently. r\FN)getattr_hook_installation_lockrO)rcs r#maybe_install_capturing_hooksrisRu95A 2 5=u E  22 +51 222sA AA )tie_last_hidden_statesc&fd}|||S|S)a Decorator to intercept specific layer outputs through hooks. The hooks are installed only once and lazily, the first time output capture is requested with the `output_xxx` kwargs/config. The implementation is fully context/thread safe, except when using `torch.compile`, as dynamo is unable to trace through `ContextVar` methods. Args: tie_last_hidden_states (`bool`, *optional*, defaults to `True`): Whether to overwrite `out.hidden_states[-1]` with the `out.last_hidden_state`. This is true for all language models and should be toggled off only if `out.hidden_states[-1]` has to be the hidden state before last layer norm, which is needed for some vision models (e.g. CLIP, SigLIP) c2tfd}|S)Nc v|jdt|jdd}tj t |j xsi}|Dcic]3}d||j d|t|jd|d5}}d|vr*|j dt|jdd|d<d|vr*|j dt|jdd|d <|jDcic]\}}|s |jdd g}}}t|d kDr t|tj|}  |g|i|} tj| |D]} | d k(rn snkt| d r*|| dd|| <|| j| j n5t| dr)|| dd|| <|| j| j"t%|| | | <|dur| j'} | Scc}wcc}}w#tj| wxYw)N return_dictToutput_Fcross_attentionsoutput_attentionsoutput_cross_attentionsmask_decoder_attentionsoutput_mask_decoder_attentionsr[rr:vision_hidden_stateslast_hidden_state)poprgconfigr]r0r^r_r`replacer=rir;r2r5hasattrr>rurwr@to_tuple)r+rBkwargsrncapturable_flagskrecordable_keysvrD output_tokenoutputsrEfuncrjs r#wrapperz4capture_outputs..wrapped_fn..wrappersj!**]GDKKX\4]^K 477DNN8KLRPR *! vzzGA3-PWXYWZm]b9cddO "%55=CZZ'>QSX)Y> 9:),<QSX)YE @AKZJ_J_Ja g$!Qef9b!92!= g  g$%)-d3,001BCL 6t5d5f5"'' 5) =/)1 *@A1B31G1L)#.)#.55g6R6RS *=>1B31G1L)#.)#.55g6O6OP$%6s%;<  =e#!**,N]!h"'' 5s8H H H H!!H8r)rrrjs` r# wrapped_fnz#capture_outputs..wrapped_fns! t4  4 lr"r!)rrjrs ` r#capture_outputsrs"8t $ r")T) rA nn.ModulerEr^rrrrreturnNone)rRrrSr^rTz list[tuple[str, OutputRecorder]]rrr/)rcrrKrrr)rcrrr)r __future__r threading contextvarsr dataclassesr functoolsrtypingr import_utilsr r rr rLrr]rr%r;rHrNrOLockrhrirr!r"r#rs #"! <0  :.. .&!*!*J**<=SW8 88(+8KO8 8,'n'n+.'n?_'n 'nT>:))..*2&KKr"