a ½ Àh|uã@sddlZddlZddlZddlmZddlmZddlmZe  e ¡Z Gdd„dej ƒZ Gdd „d ej ƒZGd d „d ej ƒZGd d „d ej ƒZGdd„dej ƒZGdd„dej ƒZd$dd„Zd%dd„Zd&dd„ZGdd„deƒZGdd„deƒZGdd„deƒZd'd d!„ZGd"d#„d#eƒZdS)(éN)Únn)ÚFunctioné)Úloggingc s,eZdZdZd ‡fdd„ Zd d d „Z‡ZS) ÚQuantEmbeddingaÞ Quantized version of `torch.nn.Embedding`. Adds quantization-specific arguments on top of `torch.nn.Embedding`. Args: weight_bit (`int`, *optional*, defaults to `8`): Bitwidth for the quantized weight. momentum (`float`, *optional*, defaults to `0.95`): Momentum for updating the activation quantization range. quant_mode (`bool`, *optional*, defaults to `False`): Whether or not the layer is quantized. Nç@Féçffffffî?c s”tƒ ¡||_||_||_||_||_||_||_t   t   ||g¡¡|_ | dt   d¡¡| dt  |j ¡¡| |_| |_| |_d|_tj|_dS)NÚweight_scaling_factoréÚweight_integerF)ÚsuperÚ__init__Znum_ÚdimÚ padding_idxÚmax_normÚ norm_typeÚscale_grad_by_freqÚsparserÚ ParameterÚtorchÚzerosÚweightÚregister_bufferÚ zeros_likeÚ weight_bitÚmomentumÚ quant_modeÚpercentile_modeÚSymmetricQuantFunctionÚapplyÚweight_function) ÚselfZnum_embeddingsZ embedding_dimrrrrrZ_weightrrr©Ú __class__©úc/var/www/html/assistant/venv/lib/python3.9/site-packages/transformers/models/ibert/quant_modules.pyr,s  zQuantEmbedding.__init__c Csº|js.tj ||j|j|j|j|j|j ¡dfS|j}|j   ¡}|  ¡  d¡}| ¡  d¡}t|j||dƒ|_| |j|j|j|j¡|_tj ||j|j|j|j|j|j ¡}||j|jfS)Nr F)rrÚ functionalZ embeddingrrrrrrÚdataÚdetachÚminÚexpandÚmaxÚ$symmetric_linear_quantization_paramsrr r!rr ) r"ÚxZ positionsZincremental_stateÚwÚ w_transformÚw_minÚw_maxZemb_intr%r%r&ÚforwardMs<ù ö  ÿù zQuantEmbedding.forward) NNrFFNrr F)NN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rr3Ú __classcell__r%r%r#r&rsô!rcs4eZdZdZd ‡fdd„ Zdd„Zd d d „Z‡ZS) ÚQuantActap Quantizes the given activation. Args: activation_bit (`int`): Bitwidth for the quantized activation. act_range_momentum (`float`, *optional*, defaults to `0.95`): Momentum for updating the activation quantization range. per_channel (`bool`, *optional*, defaults to `False`): Whether to or not use channel-wise quantization. channel_len (`int`, *optional*): Specify the channel length when set the *per_channel* True. quant_mode (`bool`, *optional*, defaults to `False`): Whether or not the layer is quantized. r FNcs–tƒ ¡||_||_||_||_d|_tj|_ |jsŠ|  dt   d¡¡|  dt   d¡¡|  dt   d¡¡|j d8_ |jd7_ntdƒ‚dS)NFÚx_minr Úx_maxÚact_scaling_factorgñh㈵øä>ú;per-channel mode is not currently supported for activation.)r rÚactivation_bitÚact_range_momentumrÚ per_channelÚ percentilerr Ú act_functionrrrr:r;ÚNotImplementedError)r"r>r?r@Z channel_lenrr#r%r&rƒs zQuantAct.__init__c Cs:|jj›d|j›d|j›d|j ¡d›d|j ¡d›d S)Nz(activation_bit=z, quant_mode: z , Act_min: z.2fz , Act_max: ú))r$r4r>rr:Úitemr;)r"r%r%r&Ú__repr__–sÿ ÿ þÿzQuantAct.__repr__c Cs°|dur |n||}|jr|jr*Jdƒ‚|jr8Jdƒ‚|j ¡}|j ¡} |  ¡ ¡dkrl| ¡ ¡dkstJdƒ‚|j ¡dkrª|j  ¡dkrª|j||_|j | |_ nd|j dkrÖt  |j|¡|_t  |j | ¡|_ n8|j|j |d|j |_|j |j | d|j |_ |j s|dfS|dur.|jn|}|durB|j n|} t |j|| |jd |_|dur~| ||j|j|j¡} nt |||j|j||¡} |j d¡} | | |jfS) Nz:percentile mode is not currently supported for activation.r=rz5NaN detected when computing min/max of the activationg¢&ú|”ç¾g¢&ú|”ç>éÿÿÿÿr )r@)ÚtrainingrAr@r(r*r,ÚisnanÚsumr:r;r?rrr-r>r<rBÚ FixedPointMulr Úview) r"r.Úpre_act_scaling_factorÚidentityÚidentity_scaling_factorZ specified_minZ specified_maxZx_actr:r;Z quant_act_intZcorrect_output_scaler%r%r&r3sH   "ÿ   ÿ ú zQuantAct.forward)r FNF)NNNNN©r4r5r6r7rrFr3r8r%r%r#r&r9rs ùr9cs8eZdZdZd ‡fdd„ Z‡fdd „Zdd d „Z‡ZS)Ú QuantLineara8 Quantized version of `torch.nn.Linear`. Adds quantization-specific arguments on top of `torch.nn.Linear`. Args: weight_bit (`int`, *optional*, defaults to `8`): Bitwidth for the quantized weight. bias_bit (`int`, *optional*, defaults to `32`): Bitwidth for the quantized bias. per_channel (`bool`, *optional*, defaults to `False`): Whether or not to use channel-wise quantization. quant_mode (`bool`, *optional*, defaults to `False`): Whether or not the layer is quantized. Tré Fcs®tƒ ¡||_||_t t ||g¡¡|_|  dt  |j¡¡|  dt |j¡¡|r~t t |¡¡|_ |  dt  |j ¡¡||_ ||_ ||_||_||_ d|_tj|_dS)Nr Úfc_scaling_factorÚ bias_integerF)r rÚ in_featuresÚ out_featuresrrrrrrrÚbiasrrr@Úbias_bitrrr r!)r"rUrVrWrrXr@rr#r%r&rës  zQuantLinear.__init__cs*tƒ ¡}d|›d|j›d|j›d}|S)Nú(z weight_bit=z , quant_mode=rD)r rFrr)r"Úsr#r%r&rFs zQuantLinear.__repr__Nc Cs |js tjj||j|jddfS|dur2|jdks:Jdƒ‚|j}|j ¡}|j rzt j |ddd\}}t j |ddd\}}n|  ¡  d¡}|  ¡  d¡}t|j|||j ƒ|_| |j|j|j|j¡|_|j|}|jdurî| |j|jd|¡|_| dd¡}||} tjj| |j|jd||fS)N)rrW)r z«Input activation to the QuantLinear layer should be globally (non-channel-wise) quantized. Please add a QuantAct layer with `per_channel = True` before this QuantAct layerr )rÚoutFrG)rrr'ZlinearrrWÚshaper(r)r@rr*r,r+r-rrSr!rr rXrTrL) r"r.Zprev_act_scaling_factorr/r0r1Ú_r2Zbias_scaling_factorÚx_intr%r%r&r3s0ÿ ÿ   þzQuantLinear.forward)TrrRFF)NrPr%r%r#r&rQÜs ÿ rQcs4eZdZdZd ‡fdd„ Zdd„Zd d d „Z‡ZS) ÚIntGELUa} Quantized version of `torch.nn.GELU`. Adds quantization-specific arguments on top of `torch.nn.GELU`. Args: quant_mode (`bool`, *optional*, defaults to `False`): Whether or not the layer is quantized. force_dequant (`str`, *optional*, defaults to `"none"`): Force dequantize the layer if either "gelu" or "nonlinear" is given. TÚnonecsjtƒ ¡||_|dvr(t d¡d|_|js8t ¡|_d|_d|_ gd¢|_ |j d|j d<dS) N)Ú nonlinearZgeluzForce dequantize geluFg à- ö?é)g]mÅþ²{Ò¿gçû©ñÒMü¿r ér) r rrÚloggerÚinforZGELUÚ activation_fnÚkÚconstÚcoeff)r"rÚ force_dequantr#r%r&r7s    zIntGELU.__init__cCsšt |jd|¡}t |jd|d¡}t |¡}t t |¡| ¡}|||d|}|d|jd}t |d|j¡}|d|j}||fS©Nr rcr) rÚfloorriÚsignr*ÚabsÚ floor_ster rh)r"r^Úscaling_factorÚb_intÚc_intrmZabs_intÚy_intr%r%r&Úint_erfGs zIntGELU.int_erfNcCs^|js| |¡dfS||}| |||j¡\}}d|}|||}||d}|||fS)Nçð?rc)rrfrtrg)r"r.rpr^Z sigmoid_intZsigmoid_scaling_factorZ shift_intr%r%r&r3Vs  zIntGELU.forward)Tr`)N)r4r5r6r7rrtr3r8r%r%r#r&r_,s r_cs:eZdZdZd ‡fdd„ Zdd„Zdd „Zd d „Z‡ZS) Ú IntSoftmaxaØ Quantized version of `torch.nn.Softmax`. Adds quantization-specific arguments on top of `torch.nn.Softmax`. Args: output_bit (`int`): Bitwidth for the layer output activation. quant_mode (`bool`, *optional*, defaults to `False`): Whether or not the layer is quantized. force_dequant (`str`, *optional*, defaults to `"none"`): Force dequantize the layer if either "softmax" or "nonlinear" is given. Fr`csŽtƒ ¡||_d|_||_|dvr4t d¡d|_td|jd|_d|_ d|_ gd ¢|_ |j d |j d <|j d |j d <dS) NrR)raÚsoftmaxzForce dequantize softmaxFé©rgvq à-æ¿é)gN„ª$ôëÖ?g¾Ã'|:ï?rur rrc) r rÚ output_bitÚmax_bitrrdrer9ÚactÚx0rhÚcoef)r"r{rrjr#r%r&rrs   zIntSoftmax.__init__cCs~t ¡<t |jd|¡}t |jd|d¡}Wdƒn1sJ0Y||||}|jd|d}||fSrk)rÚno_gradrlr)r"r^rprqrrÚzr%r%r&Úint_polynomialƒs  6zIntSoftmax.int_polynomialcCs¬t ¡ t |j|¡}Wdƒn1s.0Yt ||j|¡}t ||¡}|||}| ||¡\}}tj t |d|j|¡dd}|d|j}||fS)Nrcr©r*) rr€rlr~r,rhror r‚Úclamp)r"r^rpZx0_intÚqÚrÚexp_intÚexp_scaling_factorr%r%r&Úint_exp‹s . "zIntSoftmax.int_expc Cs¾|jstjj|dddfS||}|jddd\}}||}| ||¡\}}| ||¡\}}||}|jddd} t  d|j | ¡} t  || d|j |j ¡}dd|j }|||fS)NrG©rT)rÚkeepdimrcr ) rrr'rwr,r‰r}rJror r|r{) r"r.rpr^Z x_int_maxr]r‡rˆÚexpZ exp_int_sumÚfactorr%r%r&r3—szIntSoftmax.forward)Fr`) r4r5r6r7rr‚r‰r3r8r%r%r#r&rves   rvcs<eZdZdZd‡fdd„ Zdd„Zd d „Zdd d „Z‡ZS)Ú IntLayerNormaû Quantized version of `torch.nn.LayerNorm`. Adds quantization-specific arguments on top of `torch.nn.LayerNorm`. Args: output_bit (`int`, *optional*, defaults to `8`): Bitwidth for the layer output activation. quant_mode (`bool`, *optional*, defaults to `False`): Whether or not the layer is quantized. force_dequant (`str`, *optional*, defaults to `"none"`): Force dequantize the layer if either "layernorm" or "nonlinear" is given. rFr`cs’tƒ ¡||_||_t t |¡¡|_t t |¡¡|_ ||_ |dvrXt   d¡d|_ |  dt d¡¡||_d|_d|_t|j|j d|_dS)N)raZ layernormzForce dequantize layernormFÚshiftr rRry)r rÚnormalized_shapeÚepsrrrrrrWrrdrerr{r|Údim_sqrtr9Z activation)r"rr‘r{rrjr#r%r&r¹s  zIntLayerNorm.__init__cCsœt ¡€|d}tj|ddd}t t |d|j¡¡ ¡ ¡}|j}t |j|¡|_t   dt |ƒ›dt |jƒ›¡Wdƒn1sŽ0YdS)NrcT©Zaxisr‹zDynamic shift adjustment: z -> ) rr€rJÚlog2Úsqrtr|Úceilr,rrdreÚint)r"rsÚy_sq_intÚvar_intrZ shift_oldr%r%r&Ú set_shiftÌs "zIntLayerNorm.set_shiftcCs:| |¡t |d|j¡}|d}tj|ddd}|S)z± This fallback function is called when overflow is detected during training time, and adjusts the `self.shift` to avoid overflow in the subsequent runs. rcTr“)ršror rrrJ)r"rsÚ y_int_shiftedr˜r™r%r%r&Úoverflow_fallbackÕs  zIntLayerNorm.overflow_fallbackNcCs²|js\|jddd}||}tj|dddd}|t |j|¡}||j|j}|dfS|jdurtj|j dtj d}t |¡  |j ¡|_||}t  |jddd¡}||} t | d|j¡} | d} tj| ddd} |jr&|  ¡d|jkr&| | ¡} |  ¡d|jdks&Jdƒ‚t t | ¡¡d|j} t d| ¡}t | |d¡} |jd}|jj ¡|jj ¡}t ||¡}| |} ||j}| |}||fS) NrcTr“)Zdtypegš™™™™™¹?zfError detected in overflow handling: `var_int` exceeds `self.max_bit` (the maximum possible bit width)li@)rÚmeanrr•r‘rrWr’Útensorr\ÚfloatÚtoÚdeviceÚ round_ster rorrJrHr,r|rœr(r))r"r.rprÚyÚvarÚnr^Zmean_intrsr›r˜r™Zstd_intrrWZbias_intr%r%r&r3às@  ÿ  zIntLayerNorm.forward)rFr`)N) r4r5r6r7rršrœr3r8r%r%r#r&rŽ¬s    rŽFc Cs€|jd}t|d|dƒ}t||dƒ}tj||dj}|dkrP|d}ntj| |dj }|sx| ¡}| ¡}||fS)aÆ Calculate the percentile max and min values in a given tensor Args: input (`torch.Tensor`): The target tensor to calculate percentile max and min. lower_percentile (`float`): If 0.1, means we return the value of the smallest 0.1% value in the tensor as percentile min. upper_percentile (`float`): If 99.9, means we return the value of the largest 0.1% value in the tensor as percentile max. output_tensor (`bool`, *optional*, defaults to `False`): If True, this function returns tensors, otherwise it returns values. Returns: `Tuple(torch.Tensor, torch.Tensor)`: Percentile min and max value of *input* rr g{®Gáz„?)rg)r\ÚroundrZkthvalueÚvaluesrE) ÚinputZlower_percentileZupper_percentileZ output_tensorZ input_lengthZ lower_indexZ upper_indexÚ upper_boundÚ lower_boundr%r%r&Úget_percentile_min_maxs  r«cCs¢t|jƒdkr0| dddd¡}| dddd¡}nrƒN)rr€r,Ústackrnr„)Znum_bitsZsaturation_minZsaturation_maxr@r¥r®r]r%r%r&r-Xs (0r-c@s(eZdZdZedd„ƒZedd„ƒZdS)rzw Class to quantize the given floating-point values using symmetric quantization with given range and bitwidth. cCsNtjd|jd}d|dd}t|||dd}t || |d¡}||_|S)a6 Args: x (`torch.Tensor`): Floating point tensor to be quantized. k (`int`): Quantization bitwidth. percentile_mode (`bool`): Whether or not to use percentile calibration. scale (`torch.Tensor`): Pre-calculated scaling factor for *x*. Note that the current implementation of SymmetricQuantFunction requires pre-calculated scaling factor. Returns: `torch.Tensor`: Symmetric-quantized value of *input*. g)r¡rcr F)r°)rržr¡r±r„r®)Úctxr.rgrr®r¯r¥Z new_quant_xr%r%r&r3}s zSymmetricQuantFunction.forwardcCsb|j}t|jƒdkr&| dddd¡}n&t|jƒdkrB| dd¡}n | d¡}| ¡|ddddfS)Nr¬rGr rc)r®r­r\rLÚclone)r³Ú grad_outputr®r%r%r&Úbackward—s zSymmetricQuantFunction.backwardN©r4r5r6r7Ú staticmethodr3r¶r%r%r%r&rxs  rc@s(eZdZdZedd„ƒZedd„ƒZdS)roz; Straight-through Estimator(STE) for torch.floor() cCs t |¡S©N)rrl©r³r.r%r%r&r3ªszfloor_ste.forwardcCs| ¡Sr¹©r´©r³rµr%r%r&r¶®szfloor_ste.backwardNr·r%r%r%r&ro¥s  roc@s(eZdZdZedd„ƒZedd„ƒZdS)r¢z; Straight-through Estimator(STE) for torch.round() cCs t |¡Sr¹)rr¦rºr%r%r&r3¸szround_ste.forwardcCs| ¡Sr¹r»r¼r%r%r&r¶¼szround_ste.backwardNr·r%r%r%r&r¢³s  r¢écCs®| ¡}| d¡}t | ¡ ¡¡\}}g}|D]6}tt |d|¡j t d¡tj dƒ}|  |¡q0t  |¡}t |ƒ|}t |¡ |j¡ |¡t |¡ |j¡ |¡fS)zü Decompose the scaling factor into mantissa and twos exponent. Args: scaling_factor (`torch.Tensor`): Target scaling factor to decompose. Returns: ``Tuple(torch.Tensor, torch.Tensor)`: mantisa and exponent rGrcÚ1)Úrounding)ÚsizerLÚnpÚfrexpÚcpuÚnumpyr—ÚdecimalÚDecimalÚquantizeÚ ROUND_HALF_UPÚappendÚarrayrŸrZ from_numpyr r¡)Úinputsr|Zshape_of_inputZoutput_mZoutput_eZtmp_mÚmZ int_m_shiftedr%r%r&Ú batch_frexpÁs  "ÿ   þrÍc@s*eZdZdZeddd„ƒZedd„ƒZdS)rKaQ Function to perform fixed-point arithmetic that can match integer arithmetic on hardware. Args: pre_act (`torch.Tensor`): Input tensor. pre_act_scaling_factor (`torch.Tensor`): Scaling factor of the input tensor *pre_act*. bit_num (`int`): Quantization bitwidth. z_scaling_factor (`torch.Tensor`): Scaling factor of the output tensor. identity (`torch.Tensor`, *optional*): Identity tensor, if exists. identity_scaling_factor (`torch.Tensor`, *optional*): Scaling factor of the identity tensor *identity*, if exists. Returns: `torch.Tensor`: Output tensor(*pre_act* if *identity* is not given, otherwise the addition of *pre_act* and *identity*), whose scale is rescaled to *z_scaling_factor*. NcCsšt|jƒdkrdd„}ndd„}||_d|dd}t ¡D||ƒ}|durZ||ƒ}||_t ||¡} | tj¡} | tj ¡ tj¡} | | } || ƒ} t | ƒ\} }|  tj¡|  tj¡}t |d|¡}|durZt ||¡}| tj¡} | tj ¡ tj¡} | | } || ƒ} t | ƒ\}}| tj¡| tj¡}t |d|¡}||}t  | tj ¡| d|¡WdƒS1sŒ0YdS)NrcSs|Sr¹r%©r.r%r%r&Úóz'FixedPointMul.forward..cSs| ddd¡S)Nr rG)rLrÎr%r%r&rÏrÐrcr r) r­r\rNrr€Úz_scaling_factorr¦ÚtypeÚdoublerŸrÍr„)r³Zpre_actrMZbit_numrÑrNrOZreshaper¥Zz_intZ_AZ_BZ new_scalerÌÚeÚoutputZwx_intÚm1Úe1Zoutput1r%r%r&r3ús:        zFixedPointMul.forwardcCs8d}|jdur| ¡|j}| ¡|jdddd|dfSr¹)rNr´rÑ)r³rµZ identity_gradr%r%r&r¶/s zFixedPointMul.backward)NNr·r%r%r%r&rKãsù 4rK)F)F)F)r½)rÅrÄrÁrrZtorch.autogradrÚutilsrZ get_loggerr4rdÚModulerr9rQr_rvrŽr«r±r-rror¢rÍrKr%r%r%r&Ús(    SjP9Ge $ # - "