sg HH  !RS#%K C:  !K (29(=K W %,:3,?K [ )  C1AB  !K (29(=K W %,:3,?,BK [ )IIcN R=G # " 9M(MbME((9Sb>2K"-">"F "-">"F "j05HJ5V#% C ,67J,K C )"3'446q9!.get_prefixs2v76C<7r statsN)named_children isinstanceLoggerr?_get_logger_dict_helper)r8r9r:r>namechild module_prefixs rrCrC|s8))+ e eV $8= K 6*W4 5  ))+C e5; 6*T1 {MBCr cbtjjdi}t||||S)aTraverse the modules and save all logger stats into target dict. This is mainly used for quantization accuracy debug. Type of loggers supported: ShadowLogger: used to log the outputs of the quantized module and its matching float shadow module, OutputLogger: used to log the outputs of the modules Args: mod: module we want to save all logger stats prefix: prefix for the current module Return: target_dict: the dictionary used to save all logger stats z/quantization_api._numeric_suite.get_logger_dict)r,r-r.rC)r8r:r9s rget_logger_dictrHs.  HH  !RS#%KCf5 r c(eZdZdZfdZdZxZS)rBzBase class for stats loggingcZt|i|_tj|_yN)super__init__r?r,quint8dtypeself __class__s rrMzLogger.__init__s"  \\ r cy) Nr=rQxs rforwardzLogger.forwardsr __name__ __module__ __qualname____doc__rMrW __classcell__rRs@rrBrBs'" r rBc(eZdZdZfdZdZxZS) ShadowLoggerz^Class used in Shadow module to record the outputs of the original and shadow modules. c^t|g|jd<g|jd<y)Nr%r&rLrMr?rPs rrMzShadowLogger.__init__s*   7"$ ;r ct|dkDr|d}t|dkDr|d}|jdj|j|jdj|jy)rTr+rr&r%N)rr?appenddetach)rQrVys rrWzShadowLogger.forwardsf q6A:!A q6A:!A ;&&qxxz2 7""188:.r rXr^s@rr`r`s% /r r`c(eZdZdZfdZdZxZS) OutputLoggerz+Class used to log the outputs of the modulec@t|g|jd<y)N tensor_valrbrPs rrMzOutputLogger.__init__s #% < r cB|jdj||S)rTrj)r?rdrUs rrWzOutputLogger.forwards < ''*r rXr^s@rrhrhs6&r rhtcdt|tur|Dcgc] }t|c}S|Scc}wrK)typetuple_convert_tuple_to_listrlrVs rrprps,59!W5Eq 1! "1 % 1L1L 1s-ct|tur|Dcgc] }t|c}S|jr|j S|Scc}wrK)rnlist_dequantize_tensor_list is_quantized dequantizerqs rrtrtsP 7d?.//  #/ >>\\^  /sA ceZdZdZfdZdej fdZdej dej dej fdZdej de dej fdZ dej dej dej fd Z dej de dej fd Z dde ej d edej fd Zdej dej dej fd ZxZS)ShadowaShadow module attaches the float module to its matching quantized module as the shadow. Then it uses Logger module to process the outputs of both modules. Args: q_module: module quantized from float_module that we want to shadow float_module: float module used to shadow q_module logger_cls: type of logger used to process the outputs of q_module and float_module. ShadowLogger or custom loggers can be used. ct|||_||_t j |_||_yrK)rLrM orig_module shadow_modulennq DeQuantizedequantlogger)rQq_module float_module logger_clsrRs rrMzShadow.__init__s5 #)~~'  l r rct|}|j|}t|}|j|}|j |||SrT)rprzrtr{r)rQrVxloutputxl_float shadow_outputs rrWzShadow.forwardsO $A &!!!2&*2.***H5  FM* r rVrfc|jj||}|j}|j}|jj||}|j |||Sr)rzaddrvr{rrQrVrfrrs rrz Shadow.add] !!%%a+ LLN LLN**..q!4  FM* r c|jj||}|j}|jj||}|j |||Sr)rz add_scalarrvr{rrs rrzShadow.add_scalarR !!,,Q2 LLN**55a;  FM* r c|jj||}|j}|j}|jj||}|j |||Sr)rzmulrvr{rrs rrz Shadow.mul*rr c|jj||}|j}|jj||}|j |||Sr)rz mul_scalarrvr{rrs rrzShadow.mul_scalar6rr dimc|jj||}|Dcgc]}|j}}|jj||}|j |||Scc}wr)rzcatrvr{r)rQrVrrrfrs rrz Shadow.catAse !!%%a-%& 'Q\\^ ' '**..q#6  FM*  (sA*c|jj||}|j}|j}|jj||}|j |||Sr)rzadd_relurvr{rrs rrzShadow.add_reluLs] !!**1a0 LLN LLN**33Aq9  FM* r )r)rYrZr[r\rMr,TensorrWrr%rrrrintrrr]r^s@rrxrxs # U\\  U\\ ell u||  ELL U u||  U\\ ell u||  ELL U u||  T%,,' c %,,  %,, 5<< ELL r rxrrmodule_swap_listrctjjdi}|jD] \}}|||< i}|jD]U\}}||vr ||}t ||vrt ||||t ||vs9t ||rFt|||||<W|jD]\} } | |j| <y)aPrepare the model by attaching the float module to its matching quantized module as the shadow if the float module type is in module_swap_list. Example usage:: prepare_model_with_stubs(float_model, q_model, module_swap_list, Logger) q_model(data) ob_dict = get_logger_dict(q_model) Args: float_module: float module used to generate the q_module q_module: module quantized from float_module module_swap_list: list of float module types to attach the shadow logger_cls: type of logger to be used in shadow module to process the outputs of quantized module and its float shadow module z8quantization_api._numeric_suite.prepare_model_with_stubsN) r,r-r.r@rnprepare_model_with_stubs_is_identical_module_typerxitems_modules) rrrrfloat_module_childrenrDr8reassign float_modr1values rrrYs, HH  B!002* c&)d#*H,,.@ c , , )$/  ?"2 2 $Y5Ez R  ?. .7P 8 $CJ?HTN@ nn&' U!&#'r c|jDcgc] }t|}}|jDcgc] }t|}}||k(Scc}wcc}wrK)modulesrn)mod1mod2r8mod1_module_typesmod2_module_typess rrrsR.2lln=sc==.2lln=sc==  1 11>=s AA)r float_modelq_modelctjjdt||||||t |}|S)aCompare quantized module in a model with its floating point counterpart, feeding both of them the same input. Return a dict with key corresponding to module names and each entry being a dictionary with two keys 'float' and 'quantized', containing the output tensors of quantized and its matching float shadow module. This dict can be used to compare and compute the module level quantization error. This function first call prepare_model_with_stubs() to swap the quantized module that we want to compare with the Shadow module, which takes quantized module, corresponding float module and logger as input, and creates a forward path inside to make the float module to shadow quantized module sharing the same input. The logger can be customizable, default logger is ShadowLogger and it will save the outputs of the quantized module and float module that can be used to compute the module level quantization error. Example usage:: module_swap_list = [torchvision.models.quantization.resnet.QuantizableBasicBlock] ob_dict = compare_model_stub(float_model,qmodel,module_swap_list, data) for key in ob_dict: print(key, compute_error(ob_dict[key]['float'], ob_dict[key]['quantized'].dequantize())) Args: float_model: float model used to generate the q_model q_model: model quantized from float_model module_swap_list: list of float module types at which shadow modules will be attached. data: input data used to run the prepared q_model logger_cls: type of logger to be used in shadow module to process the outputs of quantized module and its float shadow module z2quantization_api._numeric_suite.compare_model_stub)r,r-r.rrH)rrrrdataob_dicts rcompare_model_stubrs=L HH  !UV['3CZP TNg&G Nr c$tjjdt|}t|}i}|D]S}t ||ddk(rt t |d|d}|3i||<||d||d<||d||d<U|S) aFind the matching activation between float and quantized modules. Args: float_module: float module used to generate the q_module q_module: module quantized from float_module Return: act_dict: dict with key corresponding to quantized module names and each entry being a dictionary with two keys 'float' and 'quantized', containing the matching float and quantized activations z8quantization_api._numeric_suite.get_matching_activationsrjrT)reverser?r%r&)r,r-r.rHrrsorted)rrr!r"act_dictr1r2s rget_matching_activationsrs HH  B!.J$X.N "HK ~c"<0 1Q 6 z4 @#wO  HSM%/ %:<%HHSM' ")7)<\)JHSM+ &K Or ctjjd| t}tjj j |d}||_t|d|i||_t|d|tiy)aPrepare the model by attaching the logger to both float module and quantized module if they are in the allow_list. Args: float_module: float module used to generate the q_module q_module: module quantized from float_module logger_cls: type of logger to be attached to float_module and q_module allow_list: list of module types to attach logger z5quantization_api._numeric_suite.prepare_model_outputsN) activationr$T)inplace allow_listprepare_custom_config_dict)rrobserver_non_leaf_module_listr) r,r-r.r ao quantizationQConfigqconfigr *NON_LEAF_MODULE_TO_ADD_OBSERVER_ALLOW_LIST)rrrr qconfig_debugs rprepare_model_outputsrs HH  ?;= HH))11ZPT1UM(L dzVX%H &P#% r )rrctjjd| t}t ||||||||t ||}|S)aUCompare output activations between float and quantized models at corresponding locations for the same input. Return a dict with key corresponding to quantized module names and each entry being a dictionary with two keys 'float' and 'quantized', containing the activations of quantized model and float model at matching locations. This dict can be used to compare and compute the propagation quantization error. Example usage:: act_compare_dict = compare_model_outputs(float_model, qmodel, data) for key in act_compare_dict: print( key, compute_error( act_compare_dict[key]['float'], act_compare_dict[key]['quantized'].dequantize() ) ) Args: float_model: float model used to generate the q_model q_model: model quantized from float_model data: input data used to run the prepared float_model and q_model logger_cls: type of logger to be attached to float_module and q_module allow_list: list of module types to attach logger Return: act_compare_dict: dict with key corresponding to quantized module names and each entry being a dictionary with two keys 'float' and 'quantized', containing the matching float and quantized activations z5quantization_api._numeric_suite.compare_model_outputs)r,r-r.r rr)rrrrract_compare_dicts rcompare_model_outputsrsZL HH  ?;= +w JG TN/ WE r )r)-typingrrrrrrr r,torch.ao.nn.quantizedrnnr&r|torch.ao.nn.quantized.dynamicdynamicnnqdtorch.nntorch.ao.quantizationr +torch.ao.quantization.quantization_mappingsr LinearLSTMrstrrrr7ModulerCrHrBr`rhrprtrxrnrrrrrrr=r rrsBBB ##,,)  KKJJIIGG .*DcNDI-. c] BBS#XB04S#XB #tC%& &'BPC Cc3hC C C4Cc4i. RYY $/6/. 6  McMcMssbRYYbJ0'))0'ii0'$i0' 0'  0'f2 ** YY*$i*  #t)_ *Z))ii #tC%& &'F !))!ii!  !P // YY/  #tC%& &' /r