Pi5ddlZddlZddlZddlZddlZddlZddlmZddlmZddl m Z ddl m Z m Z mZmZddlZddlmcmcmZddlmZgdZejdejjd e fd ZdKd Zd ZdZdZdZdej dej d ej fdZ!dZ"de#de#d e#fdZ$dLdZ%dZ&dMdZ'GddejjZ(dNdZ)d ej*d e+fd!Z,d"Z-d#Z.d$Z/Gd%d&Z0 d'Z1d(Z2d)Z3d*Z4dOd+Z5d,Z6d-e d.e fd/Z7d-e d.e d e fd0Z8d1Z9Gd2d3ej Z:d4Z;d5Zd8Z?d9e#d:e#d e+fd;Z@d<ZAd=ZBd>ZCd9e#d:e#d e+fd?ZDdPdAZEdQdCZFdDZGdEeHdFeHfdGZIdHZJGdIdJejjZKdS)RNreduce)versiongcd)AnyCallableOptionalType)return_and_correct_aliasing)benchmark_modelprofiler_runnerget_available_devicesget_compute_capability(benchmark_torch_function_in_microseconds find_multiple_register_custom_opget_model_size_in_bytesunwrap_tensor_subclassTorchAOBaseTensoris_cuda_version_at_leastis_MI300is_sm_at_least_89is_sm_at_least_90is_sm_at_least_100is_package_at_least DummyModulemodulereturnc"d|Dd|Dz}t|dks Jd|t|dkrtt |nd}|S)z Returns the unique device for a module, or None if no device is found. Throws an error if multiple devices are detected. ch|] }|j Sdevice.0ps a/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/torchao/utils.py z0_assert_and_get_unique_device..1s555Aqx555ch|] }|j Sr"r#r%s r(r)z0_assert_and_get_unique_device..1s'999999r*zKprepare only works with cpu or single-device CUDA modules, but got devices rN) parametersbufferslennextiter)rdevicesr$s r(_assert_and_get_unique_devicer3+s 65!2!2!4!455599 ..**999G w<<1    %" % %   %(LL1$4$4T$w-- $F Mr*r"c|i}|=t|tjjs Jdt |j}|dkrtjtjd}tjd}| t|D]F}tj j d5||i|dddn #1swxYwYG| tj|||z S|dkrtjtjjd}tjjd}| t|D]F}tj j d5||i|dddn #1swxYwYG| tj|||z S|dkrtjt%j}t|D]F}tj j d5||i|dddn #1swxYwYGt%j} tj| |z |z } | SdS) z?Benchmark model runs with `args` and `kwargs` both are optionalNzFExpecting `model` to be torch.nn.Module if device_type is not providedcudaT) enable_timingz timed regionmpscpu) isinstancetorchnnModuler3typer5 synchronizeEventrecordrangeautogradprofilerrecord_function elapsed_timer7eventr8time) modelnum_runsargskwargs device_type start_event end_event_ start_timeend_timeaverage_time_per_runs r(r r =s ~%11  T  14E::? f    j&&T&:: J$$4$88 x ' 'A(88HH ' 't&v&&& ' ' ' ' ' ' ' ' ' ' ' ' ' ' '     '' 22X==    io++$+?? IO)))== x ' 'A(88HH ' 't&v&&& ' ' ' ' ' ' ' ' ' ' ' ' ' ' '  '' 22X==    Y[[ x ' 'A(88HH ' 't&v&&& ' ' ' ' ' ' ' ' ' ' ' ' ' ' '9;;  (: 5A##  s62 DD D  H**H. 1H. , LL L ctjtjjjtjjjgd5}||i|}dddn #1swxYwY|||S)NT) activities record_shapes)r:rCprofileProfilerActivityCPUCUDAexport_chrome_trace)pathfnrJrKprofresults r(rrus    N + / N + 0    % T$V$$%%%%%%%%%%%%%%% T""" Ms A!!A%(A%c@dg}tjr|dn3tjr|dtjr|d|S)Nr8r5xpur7)r:r5 is_availableappendr`r7)r2s r(rrsgG z  v    ! !u yu Nr*c~tjrtjSdSN)r: acceleratorracurrent_acceleratorr"r*r(get_current_accelerator_devicergs3 %%'' 44666tr*ctjr>tj}t |dd|dSdS)Nr.r,g)r:r5raget_device_capabilityfloat) capabilitys r(rrsT z  9Z5577  1 77 1 77888 3r*output output_refctjtj||z tjtj|z Srd)r:meanabs)rmrns r(compute_max_diffrrsC :ei 344 5 5  *99 r*cddlmcm}||i|||i||d|||d}|}|jdzS)Nrzf(*args, **kwargs))rJrKf)stmtglobalsg.A)torch.utils.benchmarkutils benchmarkTimerblocked_autorangerp)rtrJrKryt0 measurements r(rrs---------AtvAtv  !a88   B&&((K  c !!r*nrJcVtd|dz}||zdkr|S||z||zz S)Nc.||zt||zSrdr)xys r(zfind_multiple..sQ#a))!3r*)r,rr)r~rJks r(rrs= 33TD[ A AA1uzz q5AE?r*Tc6ddlmrdndfd}|S)aThis decorator is used to preserve some high level operators for torch.export.export while still allow them to be decomposed for inductor path requirement: make sure `fn.__name__[1:]` is the operator name you want to register NOTE: This should be applied at the top, after all other decorators have been applied NOTE: We haven't tested the case when `fn` accepts tensor subclass instance as input, e.g. uint4 tensor subclass instance, and we'll probably need to figure out what would make sense for downstream system (like executorch) to accept as well Example: lib = torch.library.Library("my_namespace', "FRAGMENT") register_custom_op = _register_custom_op(lib) @register_custom_op def _the_op_that_needs_to_be_preserved(...) ... # after this, `_the_op_that_needs_to_be_preserved` will be preserved as # torch.ops.my_namespace.the_op_that_needs_to_be_preserved operator after # torch.export.export r)register_decompositionCompositeImplicitAutogradCompositeExplicitAutogradcddlm}tfddDrJdjj}|ddkr |dd}||iz}||j}tttj ||}r |g|S) Nr) infer_schemac3*K|] }|jvVdSrd)__name__)r&cr\s r( z9_register_custom_op..decorator..s*77AqBK'777777r*z.<>zEExpecting op to be defined in normal functions, not lambda or local: rOr,) mutates_args) torch._library.infer_schemaranyrdefineimplnsgetattrr:ops) r\rop_nameschema lib_namespaceop dispatch_keyinductor_decomposedlibrs ` r( decoratorz&_register_custom_op..decorators<<<<<<777777777  aTVT_ a a  7+ 1:  abbkG<<<<<< 6 "l+++ WUY 66 @ @  - ( " "B4 ( ( , , , r*)torch._inductor.decompositionr)rrrrrs`` @@r(rrsc2EDDDDD  )## ( & r*cfd}|S)Nc6|d}|S)NMeta)r)r\rrrs r(rz$_register_meta_op..decorators XXgr6 * * r*r")rrrs`` r(_register_meta_oprs* r*FcNfdd}|D]\}}t|tjjr|sat j|d|dD]}||z }|t||z }|S)z Returns the model size in bytes. The option to ignore embeddings is useful for models with disproportionately large embeddings compared to other model parameters that get quantized/sparsified. ct|dr?d}|dD] }t||}||z }!|S||zS)N__tensor_flatten__r)hasattrrrnumel element_size)tensorsize attr_name sub_tensor flat_sizes r(rz*get_model_size_in_bytes..flat_sizes 6/ 0 0 :D$6688; . . $VY77  *---K<<>>F$7$7$9$99 9r*rF)recurse) named_childrenr9r:r; Embedding itertoolschainr-r.r)rHignore_embeddings model_sizenamechildr'rs @r(rrs : : : : :J++--LL e5%("455 L:K L_   //u1M1M + +iill* 1%9JKK KJ r*ceZdZdZdZdS)UnwrapTensorSubclasscbt|}t|jD]o\}}}t|}dt ||| dD}||d}|||dd}||pt|dksJ|dS)Nci|]\}}|| Sr"r")r&abs r( z0UnwrapTensorSubclass.forward..sTTTdaQTTTr*r,r)listreversed rebuild_stackr/zip__tensor_unflatten__rb)selftensorstodotpmeta inner_tensors nb_tensorrebuilts r(forwardzUnwrapTensorSubclass.forwardsG}}'/0B'C'C ! ! #BmM**ITTc-yjkkAR.S.STTTM #D--mT4NNG KK 4yyA~~~~Awr*ct|tjusJg}g}|g}|r|}|\}}|t|||f|D]t}t ||} t| tjur|| Ct| tjsJ|| u|||_|Srd) r=r:Tensorpoprrbrr9r) rrr plain_tensorsrobjrmetadatarvals r( right_inversez"UnwrapTensorSubclass.right_inverse!sF||5<////  x %((**C&)&<&<&>&> #M8  $s))X}!E F F F* % % c9--99 ,,!((----%c5<88888KK$$$$ %+r*N)r __module__ __qualname__rrr"r*r(rrs2   r*rc|D]C\}}t|tjjst|tjjrt |drt|jtj urt|jtjj urt|jtj r|tt|jtj rPt|jtr6tj|s"tj|dt!t#|E|S)a5Unwraps (nested) tensor subclass in the model to plain tensors This is a workaround to make a model with tensor subclass to work with `torch.export.export` and `torch.aot_compile`, we hope this can be integrated into compile stack soon tracking issue: https://github.com/pytorch/ao/issues/345 weight)rr9r:r;Linearrrr=rr Parameter issubclassr parametrizeis_parametrizedregister_parametrizationrr)rH filter_fnrrs r(rr7s8 ++--&& e5%(/22 eUX%788  x((   U\""%,66U\""%(*<<<5<66=4 --u|<<=5<):;;= /66 =  0x!5!7!7    u%%%% Lr*dtypecftjtjtjtjh}||vSrd)r: float8_e4m3fnfloat8_e4m3fnuz float8_e5m2float8_e5m2fnuz)r fp8_typess r(_is_float8_typerSs.     I I r*cttjd|}tjd|}|r4t t |\}}}|rd}|||gStd|)z Parse version string representing pre-release with -1 Examples: "2.5.0.dev20240708+cu121" -> [2, 5, -1], "2.5.0" -> [2, 5, 0] z (git|dev)z(\d+)\.(\d+)\.(\d+)zInvalid version string format: )boolresearchmatchmapintgroups ValueError)version_string is_prereleasermajorminorpatchs r( parse_versionr]s<@@AAM H+^ < KKLLLr*c8ttjd S)N git_version)rr:rr"r*r( is_fbcoderosu}m44 44r*cvtrdSttjt|kS)NT)rrr: __version__) min_versions r(torch_version_at_leastrss3{{t * + +}[/I/I IIr*c(eZdZdZdedefdZdZdS)_ConfigDeprecationWrapperz A deprecation wrapper that directs users from a deprecated "config function" (e.g. `int4_weight_only`) to the replacement config class. deprecated_name config_clsc"||_||_dSrd)rr)rrrs r(__init__z"_ConfigDeprecationWrapper.__init__s.$r*c tjd|jd|jjd|jjd|j|i|S)N`zE` is deprecated and will be removed in a future release. Please use `z/` instead. Example usage: quantize_(model, z(...)))warningswarnrrrrrJrKs r(__call__z"_ConfigDeprecationWrapper.__call__st  E$ E E?3 E E$(O$< E E E   t////r*N)rrr__doc__strr rr r"r*r(rr{sO %%%%%%00000r*rctdsi_jvr ij<tttfsgfd}|S)z7Decorator to implement aten ops for __torch_dispatch__._ATEN_OP_TABLEcpD]1}tj||fd}|j|<2|S)Nc|||||Srdr"rttypesrJrK_funcs r(wrapperz/_implements..decorator..wrapperuQtV444r*) functoolswrapsr)funcrraten_opsclss r(rz_implements..decoratorsZ 2 2B _T " "6: 5 5 5# " 5+2C s #B ' ' r*)rrr9rtuple)rrrs`` r( _implementsrs} 3( ) )  #$$$"$3 hu . .: r*ctdsi_jvr ij<tttfsgfd}|S)z*Decorator to implement __torch_function__._TORCH_FN_TABLEcpD]1}tj||fd}|j|<2|S)Nc|||||Srdr"rs r(rz>_implements_torch_function..decorator..wrapperrr*)rrr)rr\rr torch_fnss r(rz-_implements_torch_function..decoratorsZ 3 3B _T " "6: 5 5 5# " 5,3C  $R ( ( r*)rrr9rr)rr!rs`` r(_implements_torch_functionr"s} 3) * *!  #%%%#%C i$ / / K  r*cR|j}|j}tjj}|tjjjjd}|tjd}|tjj gd}||j j |j j |j j |j j gd}dtdtdtfd||jj fd }||jj d }dS) Nc|t|dksJ|d}|D]}|dvsJ d|vr|d|jksJd|vr|d|jksJ|d|jkr|S|dfd}t|||S)Nr,r)rlayoutr$rr%r$c|S)Nr#r")rr$rs r(rz:_implements_common_tensor_ops.._..sa9O9O9Or*)r/keysrr%getr$_apply_fn_to_datar )rrrJrKrr new_tensorr$s` @r(rOz(_implements_common_tensor_ops.._s4yyA~~~~Aw 6 6A555555 f  '?dj0000 v  (#t{2222H%% T[ K!W../O/O/O/O/OPP *4vzJJJr*ct|dksJt|dt|dko|dj|djkS)Nrr,)r/r=shaperrrJrKs r(rOz(_implements_common_tensor_ops.._sJ4yyA~~~~DG}}T!W -P$q'-47=2PPr*cHdfdS)Nrc,|gddRiSNr,r"rrJrrKs r(rz:_implements_common_tensor_ops.._..s)443ODH3O3O3O3O3Or*)r)r.s` ``r(rOz(_implements_common_tensor_ops.._s/ Aw(()O)O)O)O)O)OPPPr*c htdfdS)Nrc,|gddRiSr1r"r2s r(rz:_implements_common_tensor_ops.._..s)Q0Labb0L0L0LV0L0Lr*)r r)r.s` ``r(rOz(_implements_common_tensor_ops.._sG+    G % %&L&L&L&L&L&L M M    r*rsrcrctfdjD}d}tdr!tfdjD}tfdjD}d}tdr!tfdjD}t t kojjko|o|o|o|S)Nc3pK|]0}t|jt|jkV1dSrdrr-r&t_namerr5s r(rzH_implements_common_tensor_ops.._same_metadata..sV" "  D& ! ! '73+?+?+E E" " " " " " r*Toptional_tensor_data_namesc3K|]R}t|,t|jt|jknt|duVSdSrdr8r9s r(rzH_implements_common_tensor_ops.._same_metadata..s// tV,,8D&))/733G3G3MMM f--5 //////r*c3\K|]&}t|t|kV'dSrdrr&a_namerr5s r(rzH_implements_common_tensor_ops.._same_metadata.. sP   D& ! !WS&%9%9 9      r*optional_tensor_attribute_namesc3\K|]&}t|t|kV'dSrdr>r?s r(rzH_implements_common_tensor_ops.._same_metadata..sP''f%%f)=)==''''''r*)alltensor_data_namesrr;tensor_attribute_namesrAr=r-)rr5_tensor_shape_match_optional_tensor_shape_match _attr_match_optional_attr_matchs`` r(_same_metadataz5_implements_common_tensor_ops.._same_metadatas!" " " " " 0" " "   (,$ 45 6 6 +.///// #= ///,, (     5     $ 4: ; ; #&'''''"B'''$$ JJ$s)) # % ci' %# %- %  % %  r*c |d}|d}||rR|d}|D]3}t||t||4dStd|d|df)Nrr,z7Not supported args for copy_ due to metadata mismatch: )rrcopy_r) rrrJrKrr5 self_tensors tensor_namerJs r(rOz(_implements_common_tensor_ops.._!sAw1g >$ $ $ 2244Q7L+ L L k**00k1J1JKKKK F Xd1gtTUwEW X X   r*c |d t drt dr  j|ddi|}|d fd jD}g}t drZ jD]R}t |}|)|| =|dS fd jD}g} t d r fd  j D}  j g|||| R} t|||| Std ) NrrDrEr,r$cVg|]%}t|&Sr")rto)r&rr$rs r( z<_implements_common_tensor_ops.._..6s>37d##&&v..r*r;c@g|]}|dkrt|nSr#r>r&rr$rs r(rRz<_implements_common_tensor_ops.._..CsB!!!-6,A,Ai(((v!!!r*rAc@g|]}|dkrt|nSr#r>rTs r(rRz<_implements_common_tensor_ops.._..IsB...!1:X0E0EGD),,,6...r*zSubclasses must implement `aten._to_copy.default` or specify `tensor_data_names` and `tensor_attribute_names` for tensor class or tensor instance before using it) r_get_to_kwargsrrDr;rrbrQrErA __class__r NotImplementedError) rrrJrKroptional_tensorstensor_data_name maybe_tensortensor_attributesoptional_tensor_attributestr$rs @@r(rOz(_implements_common_tensor_ops.._.sAw 4, - -# F' *3 3 # F)T($qrr(=f==FZZ))F;?;QG " t9:: 6(,(G66$#*41A#B#BL#/(// 0G0GHHHH(//5555!!!!!!%!<!!! *, &t>?? .....%)%I...* "", A /tT61EE E! p   r*) implementsimplements_torch_functionr:ratenrQ dtype_layout!_has_compatible_shallow_copy_typer contiguousdetachdefaultclonealiasrrrL_to_copy)rr_r`rarOrJs @r(_implements_common_tensor_opsrjsJ # = 9>DZ !.//KK0/K0uFGGQQHGQ L #  QQ  QZ K  J  J  O #     $ .$ 5F$ 4$ $ $ $ LZ "##     $#  Z %&&) ) '&) ) ) r*ct|drt|dsJtj||t |dgD],}||jvr!t||st ||d-t |dgD],}||jvr!t||st ||d-dS)NrDrEr;rA)rr:_utils_set_obj_stater__dict__setattr)rstateoptional_tensor_data_nameoptional_tensor_attribute_names r( _torchao_base_tensor__setstate__rs[s 4, - -' &33  Le,,,%,T3OQS%T%T;;! $DM 9 9' +C C 9 D3T : : :*1 /++@@& * > >w 0H H > D8$ ? ? ? @@r*c|in|}t|dr7||jvr.||j|vr|j||||||Stj5||i|cdddS#1swxYwYdS)aUse this util function for a common `__torch_function__` implementation that dispatches to ops/functions registered with `_implements` class MyTensor(torch.Tensor): ... __torch_function__ = classmethod(_dispatch__torch_function__) Nr)rrr:_CDisableTorchFunctionSubclass)rrrrJrKs r(_dispatch__torch_function__rwos>RRvF&''I 3& & & C', , ,-s"3'-dE4HHH  . . 0 0%%tT$V$$%%%%%%%%%%%%%%%%%%s,BBBc Bt|dr7||jvr.||j|vr|j||||||Std|D}d|D}t |jd|d|d|d| )aUse this util function for a common `__torch_dispatch__` implementation that dispatches to ops/functions registered with `_implements` class MyTensor(torch.Tensor): ... __torch_dispatch__ = classmethod(_dispatch__torch_dispatch__) rc34K|]}t|VdSrdr=r&args r(rz._dispatch__torch_dispatch__..s(00Cd3ii000000r*c4i|]\}}|t|Sr"rz)r&rr|s r(rz/_dispatch__torch_dispatch__..s$===FAs1d3ii===r*zC dispatch: attempting to run unimplemented operator/function: func=z, types=z , arg_types=z, kwarg_types=)rrritemsrXr)rrrrJrK arg_types kwarg_typess r(_dispatch__torch_dispatch__rs %&&H 3% % % C&s+ + +,s!#&t,T5$GGG00400000I==fllnn===K  < G GW[ G G`e G Gjs G GyD G G  r* tensor_class layout_classcDtdsi_fd}|S)a~Helper function for layout registrations, this is used to implement register_layout decorator for each tensor subclass, see aqt.py for example usage Args: tensor_class: Tensor subclass type layout_class: the class type of subclass of `Layout`, e.g. `PlainLayout` Returns: a decorator that registers the tensor impl constructor in the table _LAYOUT_CONSTRUCTOR_TABLEch|jj<tj|g|Srd) from_plainrr: serializationadd_safe_globals)tensor_impl_classrrs r(rz#_register_layout..decorators;  ( .|< ,,l.s3JJJsEL,I,IJJJJJJJr*r%)r$r)rrr:ru_nn _parse_tor$r)rrJrKr$rrOs r(rVrVs JJJJJ J JD6 8  (,0$A&AAFE1a"NT[[F-DJJUEF Mr*ceZdZdZedZeeZeeZ ee Z ee Z ee ZeeZeeZeZdZdZedZdZdZdZd S) raA util tensor subclass that provides commonly used functions new tensor subclass can inherit it to get all the utility functions class MyTensor(TorchAOBaseTensor): pass This includes: `_get_to_kwargs` that can get the kwargs for `to` class MyTensor(TorchAOBaseTensor): def to(self, *args, **kwargs): kwargs = _get_to_kwargs(*args, **kwargs) ... `implements`: implements = MyTensor.implements @implements(torch.nn.functional.linear): def _(func, types, args, kwargs): ... `register_layout`: register_layout = MyTensor.register_layout @register_layout(PlainLayout) class PlainAQTTensorImpl(...): ... `get_tensor_impl_constructor`: get_tensor_impl_constructor = MyTensor.get_tensor_impl_constructor # in constructor of MyTensor: tensor_impl_ctr = get_tensor_impl_constructor(type(_layout)) tensor_impl = tensor_impl_ctr(data, scale, zero_point, _layout) class variables to define to simplify implmentation of tensor subclasses: `tensor_data_names` (List[str]): list of names of all requires tensor_data, order should match the `__init__` list of tensor subclass `tensor_attribute_names` (List[str]): list of names of non-Tensor attributes, order should match the `__init__` list of tensor subclass, following all the `tensor_data_names` arguments `optional_tensor_data_names` (List[str]): it's optional to define this field to have the additional boilerplate functions been implemented for you, but this will be need if there are some optional Tensor data attributes, when defined, this will be a list of names of Tensors that can be optional `optional_tensor_attribute_names` (List[str]): it's optional to define this field to have the additional boilerplate functions been implemented for you, but this will be need if there are some optional non-Tensor attributes, when defined, this will be a list of names of attributes that can be optional Note: Argument order in __init__ and __new__ should match exaclty with tensor_data_names + tensor_attribute_names + optional_tensor_data_names (if present) + optional_tensor_attribute_names (if present) If `tensor_data_names` (torch.Tensor data attribute names) and `tensor_attribute_names` (non-torch.Tensor attribute names) are defined, there are some additional functions that will be added, this includes: `__tensor_flatten__`: flattens a subclassed tensor instance, returns a tuple, first element is tensor data names for valid tensor data, second element is a dict from attribute_name to non-Tensor attributes `__tensor_unflatten__`: takes a tensor_data_dict (a map from tensor name to Tensor), and list of non-tensor attributes, returns a new instance of the subclassed tensor `_apply_fn_to_data`: takes a function (Tensor -> Tensor), applies function to all tensor data and recreate a new subclassed Tensor with the transformed tensor data `__repr__`: the string representation of the subclassed tensor instance `_same_metadata`: returns whether the metadata is the same between two instances of cls `__setstate__`: when loading a serialized tensor subclass checkpoints, it sets the new optional tensor and tensor attribute that is saved in the old checkpoint to None, to maintain BC of old checkpoints when we add new optional tensor data or attributes to the tensor subclass torch ops: torch.Tensor.contiguous aten ops: aten.detach.default, aten.clone.default, aten.alias,default, aten.contiguous.default, aten.copy_.default, aten._to_copy.default (enables t.to) Example: class MyTensor(torch.Tensor): tensor_data_names = ["a", "b"] tensor_attribute_names = ["c", "d"] optional_tensor_data_names = ["e", "f"] optional_tensor_attribute_names = ["g", "h"] def __new__( cls, a: Tensor, b: Tensor, c: int, d: str, e: Optional[Tensor] = None, f: Optional[Tensor] = None, g: Optional[int] = None, h: Optional[int] = None, ): pass def __init__( self, a: Tensor, b: Tensor, c: int, d: str e: Optional[Tensor] = None, f: Optional[Tensor] = None, g: Optional[int] = None, h: Optional[int] = None, ): pass c Rt|dsi|_t|dsi|_||jvr i|j|<||jvr i|j|<t|dr0t|dr |t|_|jD]}t|dr4||jvr+|j||j|t|dr4||jvr+|j||j|dS)NrrrDrE)rrrrjrs __setstate__ __bases__update)rrKparents r(__init_subclass__z#TorchAOBaseTensor.__init_subclass__@s]s,-- $!#C s-.. %"$C  c( ( (&(C s # c) ) )')C  $ 3+ , , @>V1W1W @  - - / / /?C m M MFs,-- K&Cr&attrrs r(rz8TorchAOBaseTensor.__tensor_flatten__..ps2.2gdD))r*rAc2i|]}|t|Sr"r>rs r(rz8TorchAOBaseTensor.__tensor_flatten__..ts5)))'$--)))r*zSubclasses should implement __tensor_flatten__ or specify `tensor_data_names` and `tensor_attribute_names` for tensor class before using it) rrDcopyr;rrbrErArX)rrDrZr[ attr_dicts` r(rz$TorchAOBaseTensor.__tensor_flatten__es1 4, - - 0' *3 3  0!% 6 ; ; = = t9:: C(,(GCC$#*41A#B#BL#/)001ABBB6:6QIt>?? %)))) $ D))) %i/ /! Z   r*cbt|drt|drfd|jD}i}t|drfd|jD}fd|jD}i}t|drfd|jD}|g||Ri||St d ) NrDrEc g|] }| Sr"r")r&rtensor_data_dicts r(rRz:TorchAOBaseTensor.__tensor_unflatten__..s,   +/ &   r*r;c>i|]}||dSrd)r()r&rZrs r(rz:TorchAOBaseTensor.__tensor_unflatten__..s=((((%&6&:&:;KT&R&R(((r*c g|] }| Sr"r"r&rr\s r(rRz:TorchAOBaseTensor.__tensor_unflatten__..s,###,0!$'###r*rAc"i|] }|| Sr"r"rs r(rz:TorchAOBaseTensor.__tensor_unflatten__..s1++++D1+++r*zSubclasses should implement __tensor_unflatten__ or specify `tensor_data_names` and `tensor_attribute_names` for tensor class before using it)rrDr;rErArX) rrr\ outer_size outer_striderequired_tensorsoptional_tensor_dictrequired_attributesoptional_attribute_dicts `` r(rz&TorchAOBaseTensor.__tensor_unflatten__so 3+ , , >V1W1W     363H    $& s899 ((((,/,J((($ ####474N### ') #s=>> ++++ # C+++' 3!$'*  " \   r*ctdrtdrfdjD}i}tdr0jD](}t|}||||<#d||<)fdjD}i}tdrfdjD}jg||Ri||Std) NrDrEcBg|]}t|Sr"r>)r&rr\rs r(rRz7TorchAOBaseTensor._apply_fn_to_data..s:   ,074&&''   r*r;c0g|]}t|Sr"r>rs r(rRz7TorchAOBaseTensor._apply_fn_to_data..s0###(,d#####r*rAc2i|]}|t|Sr"r>)r&rrs r(rz7TorchAOBaseTensor._apply_fn_to_data..s5+++!wtY77+++r*zSubclasses should implement _apply_fn_to_data or specify `tensor_data_names` and `tensor_attribute_names` for tensor class or tensor instance before using it)rrDr;rrErArWrX)rr\rrrZr[rrs`` r(r)z#TorchAOBaseTensor._apply_fn_to_datas 4, - - ' *3 3       484J    $& t9:: F(,(GFF$#*41A#B#BL#/ACLAQAQ,-=>>AE,-=>>####040K### ') #t>?? ++++%)%I+++' "4>!$'*  " l   r*c Nt|drt|drd}||jddt||jdz }|jddD]}|d|dt||z }|jD]}|d|dt||z }t|dr#|jD]}|d|dt||z }t|d r#|jD]}|d|dt||z }|jjd |d Std ) NrDrEr=r,z, r;rA()zSubclasses must implement __repr__ or specify `tensor_data_names` and `tensor_attribute_names` for tensor class or tensor instance before using it) rrDrrEr;rArWrrX)rrepr_strrZtensor_attribute_names r(__repr__zTorchAOBaseTensor.__repr__s 4, - - <' *3 3  <H 41!4aawtTE[\]E^7_7_aa aH$($:122$> V V U!1UUGDBR4S4SUUU*.)D  %W.WW?T1U1UWW t9:: (,(G$Q-QQ>N0O0OQQHH t>?? d-1-Qdd) c%: c cWTK`=a=a c ccHHn-;;;;; ;! a   r*c4t|dsdS|jS)N_layout)rr)rs r( get_layoutzTorchAOBaseTensor.get_layouts!tY'' 4|r*N)rrrr  classmethodrrr_r"r`rjr__torch_dispatch__rw__torch_function__rregister_layoutrget_tensor_impl_constructorrVrrrr)rrr"r*r(rrs#\\|MM[M0[))J + ,F G G$/K0M$N$N!$%@AA$%@AA!k"233O"-+.J"K"K#N666   4! ! [! F# # # J    Dr*rc$|t|z t|krtdt|}tt||D]0}||||z t|z1|S)a __torch_dispatch__ doesn't guarantee the number of arguments you are passed (e.g., defaulted arguments are not passed); but usually it is convenient to pad out the arguments list with defaults. This function helps you do that. Args: args: the list of positional arguments passed to __torch_dispatch__ n: the number of arguments you are expecting to get defaults_tail: default values for the arguments, starting from the end of the list Example: >>> fill_defaults([1, 2, 3], 5, [3, 4, 5]) [1, 2, 3, 4, 5] >>> fill_defaults([1, 2, 3], 5, [None, None, None]) [1, 2, 3, None, None]] z%not enough defaults to fill arguments)r/ RuntimeErrorrrArb)rJr~ defaults_tailris r( fill_defaultsrs" 3}  D ))BCCC T A 3t99a << q1us='9'99:;;;; Hr*c`tjotjjSrd)r:r5rarhipr"r*r(is_ROCMrs : " " $ $ :)::r*ctr4gd}tjdj}|D] }||vrdS dS)N)gfx940gfx941gfx942rTFrr:r5get_device_properties gcnArchName) mxArchNamearchNamearchs r(rrs\yy333 :33A66B  Dxtt 5r*cvtr*tjdj}d|vrdSdS)Nrgfx950TFrrs r(is_MI350r s;yy:33A66B x  4 5r*cptr'tjdj} dSdS)Nrgfx1200gfx1201TFrrs r(is_Navi4r(s5yy:33A66B 4 5r*rrctjotjj}|r$tj||fkndS)z0Check if the CUDA version is exactly major.minorFr:r5rarrj)rris_cudas r( is_sm_versionr0sGj%%''>EM,>GCJ U5: + + - -% ? ?PUUr*ctjo2tjjo!tjdkS)N) rr"r*r(rr6@ !! 9 M  9 J , , . .& 8r*ctjo2tjjo!tjdkS)N)rrrr"r*r(rr>rr*ctjo2tjjo!tjdkS)N) rrr"r*r(rrGs@ !! : M  : J , , . .' 9r*ctjsdStjj}|dSt t |ddd\}}||f||fkS)NFrir,)r:r5rarrrsplit)rr cuda_version cuda_major cuda_minors r(rrOsq : " " $ $u=%Lu l&8&8&=&=bqb&ABBJ  #u~ 55r*2.6.0cnt|tjr|j}|dkot |S)Nr8r9r:r$r=rr$rs r(check_cpu_versionrY5&%,'' U? >5g>>>r*2.8.0cnt|tjr|j}|dkot |S)Nr`rrs r(check_xpu_versionr_rr*c||zdz |zSr1r")rrs r(ceil_divres EAI! r* package_namercrtj|du}|sdSt||kS)NF) importlibutil find_specr)rrpackage_existss r(rris<^--l;;4GN u < K //r*ctjdtjddSddl}t s |jdkrdSdS)N fbgemm_gpuzfbgemm_gpu.experimentalFrz1.2.0T)rrrfbgemm_gpu.experimental.gen_airr)rs r(_is_fbgemm_gpu_genai_availablerqse   ..6 > # #$= > > Fu)))) ;;:1G;;u 4r*cNeZdZdZddejdeejffd ZxZS)ra This is used because the TorchAO quantization functions tend to operate on modules so to apply the transform to a tensor, we can load a DummyModule with the target tensor and then apply the transformation to the module and then extract the transformed tensor. Nrbiascdt||_||_dSrd)superrrr)rrrrWs r(rzDummyModule.__init__s+   r*rd) rrrr r:rr r __classcell__)rWs@r(rrscu|8EL3Ir*r)r"NN)T)Frd)r"N)r)r)LrrrrrGrrimportlib.metadatarmathrtypingrr r r r:torch.nn.utils.parametrizer;rxrtorch.utils._python_dispatchr __all__cacher<r3r rrrgrrrrrrrrrrrrrrrrrrrrr"rjrsrwrrrrVrrrrrrrrrrrrrrr rrrr"r*r(rsL  &&&&&&000000000000 000000000000DDDDDD   , %(/c"5$5$5$5$p   U\u|  " " "S4444n<     58?   F85;4MMM$555JJJ00000000& ,,X X X v@@@(%%%%&,88:@@*2@ @@@@2&LLLLL LLL^   D;;;VVSVTVVVV 6C666666???? ???? 0c00000"%(/r*