o iC@sddlZddlZddlZddlZddlZddlmZddlmZddlm Z ddl m Z m Z m Z ddlZddlmmmZddlmZgdZejdejjd e fd d Zdvd dZddZddZddZddZdejdejd ejfddZddZ de!de!d e!fdd Z"dwd"d#Z#d$d%Z$dxd'd(Z%Gd)d*d*ejjZ&dyd+d,Z'd-ej(d e)fd.d/Z*d0d1Z+d2d3Z,d4d5Z- d6d7Z.d8d9Z/d:d;Z0dd?Z2d@dAZ3dBe dCe fdDdEZ4dBe dCe d e fdFdGZ5dHdIZ6GdJdKdKejZ7dLdMZ8dNdOZ9dPdQZ:dRdSZ;dTdUZd\d]Z?d^d_Z@dVe!dWe!d e)fd`daZAd{dcddZBd|dfdgZCdhdiZDdje!dke!d e!fdldmZEdneFdoeFfdpdqZGdrdsZHGdtduduejjZIdS)}Nreduce)versiongcd)AnyCallableOptional)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 DummyModulemodulereturncCsbdd|Ddd|DB}t|dksJd|t|dkr-tt|}|Sd}|S)z Returns the unique device for a module, or None if no device is found. Throws an error if multiple devices are detected. cSsh|]}|jqSdevice).0prrA/home/ubuntu/.local/lib/python3.10/site-packages/torchao/utils.py 0z0_assert_and_get_unique_device..zKprepare only works with cpu or single-device CUDA modules, but got devices rN) parametersbufferslennextiter)rdevicesr rrr#_assert_and_get_unique_device*sr-rc Cs|duri}|durt|tjjsJdt|j}|dkrjtjtjjdd}tjjdd}| t |D] }tj j d||i|Wdn1sTwYq9| tj|||S|dkrtjtjjjdd}tjjjdd}| t |D] }tj j d||i|Wdn1swYq| tj|||S|dkrtjt}t |D] }tj j d||i|Wdn1swYqt} tj| ||} | S|d krRtjtjjdd}tjjdd}| t |D]"}tj j d||i|Wdn 1s;wYq| tj|||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 regionmpscpuxpu) isinstancetorchnnModuler-typer. synchronizeEventrecordrangeautogradprofilerrecord_function elapsed_timer0eventr1timer2) modelnum_runsargskwargs device_type start_event end_event_ start_timeend_timeaverage_time_per_runrrr#r <sv               r cOs\tjjtjjjtjjjgdd}||i|}Wdn1s"wY|||S)NT) activities record_shapes)r4r=profileProfilerActivityCPUCUDAexport_chrome_trace)pathfnrDrEprofresultrrr#r s r cCsHdg}tjr|dn tjr|dtjr"|d|S)Nr1r.r2r0)r4r. is_availableappendr2r0)r,rrr#r s      r cCstjsJtjSN)r4 acceleratorrXcurrent_acceleratorrrrr#get_current_accelerator_devices r]cCs2tjrtj}t|dd|dSdS)Nr.r&g)r4r.rXget_device_capabilityfloat) capabilityrrr#rs  routput output_refcCs$tt||tt|SrZ)r4meanabs)rbrcrrr#compute_max_diffsrfcOsVddlmm}||i|||i||jd|||dd}|}|jdS)Nrzf(*args, **kwargs))rDrEf)stmtglobalsg.A)torch.utils.benchmarkutils benchmarkTimerblocked_autorangerd)rgrDrErlt0 measurementrrr#rs  rnrDcGs2tdd|d}||dkr|S||||S)NcSs||t||SrZr)xyrrr#r%zfind_multiple..)r&rr)rqrDkrrr#rs rTcs.ddlmr dndfdd}|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_decompositionCompositeImplicitAutogradCompositeExplicitAutogradcsddlm}tfdddDrJdjj}|ddkr(|dd}||id }||j}tttj ||}rQ|g|S) Nr) infer_schemac3s|]}|jvVqdSrZ)__name__)r!crUrr# sz9_register_custom_op..decorator..z.<>zEExpecting op to be defined in normal functions, not lambda or local: rIr&) mutates_args) torch._library.infer_schemaryanyrzdefineimplnsgetattrr4ops)rUryop_nameschema lib_namespaceop dispatch_keyinductor_decomposedlibrvr|r# decorators     z&_register_custom_op..decorator)torch._inductor.decompositionrv)rrrrrr#rs rcsfdd}|S)Ncs|d}|S)NMeta)r)rUrrrrr#rsz$_register_meta_op..decoratorr)rrrrrr#_register_meta_opsrFcstfddd}|D]+\}}t|tjjr|s7t|jdd|jddD]}||7}q'|t ||7}q |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. csJt|drd}|dD] }t||}||7}q |S||S)N__tensor_flatten__r)hasattrrrnumel element_size)tensorsize attr_name sub_tensor flat_sizerr#r s  z*get_model_size_in_bytes..flat_sizerF)recurse) named_childrenr3r4r5 Embedding itertoolschainr'r(r)rBignore_embeddings model_sizenamechildr"rrr#rs  rc@seZdZddZddZdS)UnwrapTensorSubclasscGst|}t|jD]+\}}}t|}ddt||| dD}||d}|||dd}||q t|dks=J|dS)NcSsi|]\}}||qSrr)r!abrrr# %sz0UnwrapTensorSubclass.forward..r&r)listreversed rebuild_stackr)zip__tensor_unflatten__rY)selftensorstodotpmeta inner_tensors nb_tensorrebuiltrrr#forward!s  zUnwrapTensorSubclass.forwardc Cst|tjus Jg}g}|g}|rL|}|\}}|t|||f|D]!}t||} t| tjur<|| q(t| tjsDJ|| q(|s||_|SrZ) r7r4TensorpoprrYrr3r) rrr plain_tensorsrobjrmetadatarvalrrr# right_inverse-s"     z"UnwrapTensorSubclass.right_inverseN)rz __module__ __qualname__rrrrrr#r s rcCs|D]O\}}t|tjjst|tjjrOt|drOt|jtj urOt|jtjj urOt|jtj rOt t|jtj rOt|jt rOt |sOt |dtt|q|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)rr3r4r5Linearrrr7rr Parameter issubclassr parametrizeis_parametrizedregister_parametrizationrr)rB filter_fnrrrrr#rCs,     rdtypecCstjtjtjtjh}||vSrZ)r4 float8_e4m3fnfloat8_e4m3fnuz float8_e5m2float8_e5m2fnuz)r fp8_typesrrr#_is_float8_type_s rcCsTttd|}td|}|r#tt|\}}}|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_prereleasermajorminorpatchrrr# parse_versionis  rcCsttjd S)N git_version)rr4rrrrr# is_fbcode{rcCstrdSttjt|kS)NT)rrr4 __version__) min_versionrrr#torch_version_at_leastsrcsJtdsi_jvrij<tttfsgfdd}|S)a|Decorator for implementing aten ops like `torch.ops.aten.linear.default` for tensor subclass, the implemented functions are called in ``__torch_dispatch__`` callback for ``torch.Tensor`` subclasses Examples:: implements = MyTensor.implements @implements(torch.ops.aten.linear.default): def _(func, types, args, kwargs): ... _ATEN_OP_TABLEcs2D]}t||fdd}|j|<q|S)NcS|||||SrZrrgtypesrDrE_funcrrr#wrapperz/_implements..decorator..wrapper) functoolswrapsr)funcrraten_opsclsrr#r z_implements..decorator)rrr3rtuple)rrrrrr# _implementss    rcsJtdsi_jvrij<tttfsgfdd}|S)aDecorator for implementing torch functions / ops like ``torch.nn.functional.linear``, ``torch.Tensor.t`` for the tensor subclass the implemented functions are called in ``__torch_function__`` callback for ``torch.Tensor`` subclasses Examples:: implements_torch_function = MyTensor.implements_torch_function @implements_torch_function(torch.nn.functional.linear): def _(func, types, args, kwargs): ... _TORCH_FN_TABLEcs2D]}t||fdd}|j|<q|S)NcSrrZrrrrr#rrz>_implements_torch_function..decorator..wrapper)rrr)rrUrr torch_fnsrr#rrz-_implements_torch_function..decorator)rrr3rr)rrrrrr#_implements_torch_functions    rcs|j}|j}tjj}|tjjjjdd}|tjdd}|tjj gdd}||j j |j j |j j |j j gdd}dtdtdtfd d ||jj fd d}||jj d d}dS) Ncst|dksJ|d}|D]}|dvsJqd|vr&|d|jks&Jd|vr3|d|jks3J|d|jkr?|S|dfdd}t|||S) Nr&r)rlayoutr rrr cs |dS)Nrrrrr rrr#rts :_implements_common_tensor_ops.._..)r)keysrrgetr _apply_fn_to_datar )rrrDrErru new_tensorrrr#rIs   z(_implements_common_tensor_ops.._cSs<t|dksJt|dt|dko|dj|djkS)Nrr&)r)r7shaperrrDrErrr#rIs,csdfddS)Nrc|gddRiSNr&rrrDrrErr#rtr)rrrrr#rIsc s$tdfddS)Nrcrrrrrrr#rt rr)r rrrrr#rIs  rsrcrcstfddjD}d}tdr!tfddjD}tfddjD}d}tdrBtfddjD}ttkoWjjkoW|oW|oW|oW|S) Nc3s(|]}t|jt|jkVqdSrZrrr!t_namerrrr#r}s  zH_implements_common_tensor_ops.._same_metadata..Toptional_tensor_data_namesc3sD|]}t|durt|jt|jknt|duVqdSrZr r r rr#r}s  c3$|] }t|t|kVqdSrZrr!a_namer rr#r}  optional_tensor_attribute_namesc3rrZrrr rr#r}%r)alltensor_data_namesrr tensor_attribute_namesrr7r)rr_tensor_shape_match_optional_tensor_shape_match _attr_match_optional_attr_matchrr r#_same_metadata s6    z5_implements_common_tensor_ops.._same_metadatacsd|d}|d}||r%|d}|D] }t||t||qdStd|d|df)Nrr&z7Not supported args for copy_ due to metadata mismatch: )rrcopy_r)rrrDrErr self_tensors tensor_namerrr#rI3s  c s|dtdrtdrj|ddi|}|dfddjD}g}tdrNjD]}t|}|durH||q4|dq4fd djD}g} td rkfd dj D} j g|||| R} t |||| St d ) Nrrrr&r csg|] }t|qSr)rtor!rr rrr# Hsz<_implements_common_tensor_ops.._..r c"g|] }|dkr t|nqSrrr!rr"rr#r#Urcr$rrr%r"rr#r#[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_kwargsrrr rrYr rr __class__r NotImplementedError) rrrDrEroptional_tensorstensor_data_name maybe_tensortensor_attributesoptional_tensor_attributestrr"r#rI@sJ          ) implementsimplements_torch_functionr4ratenr  dtype_layout!_has_compatible_shallow_copy_typer contiguousdetachdefaultclonealiasrrr_to_copy)rr0r1r2rIrrr#_implements_common_tensor_opss2     & r;cCst|dr t|ds Jtj||t|dgD]}||jvr+t||s+t||dqt|dgD]}||jvrDt||sDt||dq2dS)Nrrr r)rr4_utils_set_obj_stater__dict__setattr)rstateoptional_tensor_data_nameoptional_tensor_attribute_namerrr# _torchao_base_tensor__setstate__ms&     rCcCs|durin|}t|dr%||jvr%||j|vr%|j||||||Stj||i|WdS1s.cSsi|] \}}|t|qSrrG)r!rurIrrr#rsz/_dispatch__torch_dispatch__..zC dispatch: attempting to run unimplemented operator/function: func=z, types=z , arg_types=z, kwarg_types=)rrritemsr)rz)rrrrDrE arg_types kwarg_typesrrr#_dispatch__torch_dispatch__s   rM tensor_class layout_classcs"tdsi_fdd}|S)a .. deprecated:: 0.15.1 This method is deprecated as of version 0.15.1 since it's part of the older tensor subclass development stack, for information about new dev stack, please check https://docs.pytorch.org/ao/main/quantization_overview.html and https://docs.pytorch.org/ao/main/contributor_guide.html 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_TABLEcs |jj<tj|g|SrZ) from_plainrPr4 serializationadd_safe_globals)tensor_impl_classrOrNrr#rsz#_register_layout..decorator)rrP)rNrOrrrUr#_register_layouts rVcCs@t|ds td|||jvrtd|d||j|S)a .. deprecated:: 0.15.1 This method is deprecated as of version 0.15.1 since it's part of the older tensor subclass development stack, for information about new dev stack, please check https://docs.pytorch.org/ao/main/quantization_overview.html and https://docs.pytorch.org/ao/main/contributor_guide.html Get TensorImpl class constructor (TensorImplClass.from_plain) for `tensor_class` based on `layout_class` `layout_class` means the class type of subclass of `Layout`, e.g. `PlainLayout` Args: tensor_class: Tensor subclass type layout_class: the class type of subclass of `Layout`, e.g. `PlainLayout` Returns: tensor impl subclass constructor for the layout_class rPz1no registered tensor_impl class constructor for: z layout_name: z is not supported yet for )rrrP)rNrOrrr#_get_tensor_impl_constructors   rWcOsrtdd|D}d|vr|dtjjj|i|\}}}}|dur'|jn|}|dur0|jn|}||d}|S)zHelper function to get the device and dtype keyword args for `aten._to_copy.default` op only device and dtype are kept Returns: {"device": device, "dtype": dtype} css |] }t|tjs|VqdSrZ)r3r4rrHrrr#r}sz!_get_to_kwargs..rN)r r)rrr4rD_nn _parse_tor r)rrDrEr rrIrrr#r's r'c@seZdZdZeddZeeZeeZ ee Z ee Z ee ZeZeeZeeZddZddZedd Zd d Zd d ZddZdS)raA util tensor subclass that provides commonly used functions new tensor subclass can inherit to get all the utility functions Attributes (defined by subclass of ``TorchAOBaseTensor``): * :attr:`tensor_data_names` (List[str]): list of names of all required tensor_data, order should match the `__init__` list of tensor subclass (optional to define to use ``TorchAOBaseTensor``, required for getting the util functions been defined (see Note section)) * :attr:`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 to define to use ``TorchAOBaseTensor``, required for getting the util functions been defined (see Note section)) * :attr:`optional_tensor_data_names` (List[str]): it's not required to get the additional util functions been implemented, but this will be need if there are some optional ``Tensor`` data attributes, when defined, this will be a list of names of ``Tensor``s that can be optional * :attr:`optional_tensor_attribute_names` (List[str]): it's not required to get the additional util functions been implemented, 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__`` of subclass of ``TorchAOBaseTensor`` should match exaclty with ``tensor_data_names`` + ``tensor_attribute_names`` + ``optional_tensor_data_names`` (if present) + ``optional_tensor_attribute_names`` (if present) Note: If ``tensor_data_names`` (torch.Tensor data attribute names) and ``tensor_attribute_names`` (non-torch.Tensor attribute names) are defined, there are some additional util 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 function supported (``__torch_function__``): ``torch.Tensor.contiguous`` aten ops supported (``__torch_dispatch__``): ``aten.detach.default``, ``aten.clone.default``, ``aten.alias,default``, ``aten.contiguous.default``, ``aten.copy_.default``, ``aten._to_copy.default`` (enables ``t.to``) Examples:: 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 cKsd|jvri|_d|jvri|_||jvri|j|<||jvr$i|j|<t|dr5t|dr5|t|_|jD].}t|dd}|rP||vrP|j| ||t|dd}|rf||vrf|j| ||q8dS)Nrrrr) r>rrrr;rC __setstate__ __bases__rupdate)rrEparentparent_aten_tableparent_torch_tablerrr#__init_subclass__]s(           z#TorchAOBaseTensor.__init_subclass__cOstjtt|dSrZ)r4rD_log_api_usage_oncestrr7)rrDrErrr#__init__szTorchAOBaseTensor.__init__cstdrGtdrGj}tdr(jD]}t|}|dur'||qfddjD}tdrC|fddjDB}||fStd) Nrrr ci|]}|t|qSrrr!attrrrr#rs z8TorchAOBaseTensor.__tensor_flatten__..rcrdrrrergrr#r zSubclasses should implement __tensor_flatten__ or specify `tensor_data_names` and `tensor_attribute_names` for tensor class before using it) rrcopyr rrYrrr))rrr+r, attr_dictrrgr#rs*         z$TorchAOBaseTensor.__tensor_flatten__c st|drNt|drNfdd|jD}i}t|dr%fdd|jD}fdd|jD}i}t|d r@fd d|jD}|g||Ri||Std ) Nrrcg|]}|qSrrr!tensor_data_dictrr#r#z:TorchAOBaseTensor.__tensor_unflatten__..r csi|] }||dqSrZ)r)r!r+rlrr#rs z:TorchAOBaseTensor.__tensor_unflatten__..crkrrr!r-rr#r#rnrcsi|]}||qSrrr!rorr#rszSubclasses should implement __tensor_unflatten__ or specify `tensor_data_names` and `tensor_attribute_names` for tensor class before using it)rrr rrr)) rrmr- outer_size outer_striderequired_tensorsoptional_tensor_dictrequired_attributesoptional_attribute_dictr)r-rmr#rs:      z&TorchAOBaseTensor.__tensor_unflatten__cstdr`tdr`fddjD}i}tdr6jD]}t|}|dur1|||<qd||<qfddjD}i}tdrQfdd jD}jg||Ri||Std ) Nrrcsg|] }t|qSrrrerUrrr#r#sz7TorchAOBaseTensor._apply_fn_to_data..r csg|]}t|qSrrrergrr#r#s rcrdrrr%rgrr#rrhz7TorchAOBaseTensor._apply_fn_to_data..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)rrr rrrr(r))rrUrrrsr+r,rtrurrvr#rsB         z#TorchAOBaseTensor._apply_fn_to_datacCs t|drt|drd}||jddt||jd7}|jddD]}|d|dt||7}q%|jD]}|d|dt||7}q8t|dr`|jD]}|d|dt||7}qPt|d rx|jD]}|d|dt||7}qh|jjd |d Std ) Nrrr=r&z, r r()zSubclasses must implement __repr__ or specify `tensor_data_names` and `tensor_attribute_names` for tensor class or tensor instance before using it) rrrrr rr(rzr))rrepr_strr+tensor_attribute_namerrr#__repr__s. $     zTorchAOBaseTensor.__repr__cCst|dsdS|jS)ax .. deprecated:: 0.15.1 This method is deprecated as of version 0.15.1 since it's part of the older tensor subclass development stack, for information about new dev stack, please check https://docs.pytorch.org/ao/main/quantization_overview.html and https://docs.pytorch.org/ao/main/contributor_guide.html _layoutN)rr~rgrrr# get_layout s zTorchAOBaseTensor.get_layoutN)rzrr__doc__ classmethodr`rr0rr1r;rM__torch_dispatch__rF__torch_function__r'rVregister_layoutrWget_tensor_impl_constructorrcrrrr}rrrrr#rs&T  #% "rcCsV|t|t|krtdt|}tt||D]}||||t|q|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) RuntimeErrorrr;rY)rDrq defaults_tailrirrr# fill_defaultss rcCstjotjjSrZ)r4r.rXrhiprrrr#is_ROCM=srcCs8trgd}tjdj}|D] }||vrdSqdS)N)gfx940gfx941gfx942rTFrr4r.get_device_properties gcnArchName) mxArchNamearchNamearchrrr#rAsrcCs$trtjdj}d|vrdSdS)Nrgfx950TFrrrrr#is_MI350Ks rcCstr tjdj} dSdS)Nrgfx1200gfx1201TFrrrrr#is_Navi4Ss rrrcCs,tjotjj}|rtj||fkSdS)z0Check if the CUDA version is exactly major.minorFr4r.rXrr_)rris_cudarrr# is_sm_version[srcC tjotjjotjdkS)N) rrrrr#ra  rcCr)N)rrrrrrr#rirrcCr)N) rrrrrr#rrrrcCsNtjsdStjj}|durdStt|ddd\}}||f||fkS)NFr^r)r4r.rXrrrsplit)rr cuda_version cuda_major cuda_minorrrr#rzs r2.6.0cC"t|tjr |j}|dkot|S)Nr1r3r4r r7rr rrrr#check_cpu_version r2.8.0cCr)Nr2rrrrr#check_xpu_versionrrcCs||d|Srrrrrrr#ceil_divsrrrcCst|||SrZ)rrrrr#round_uprr package_namercCs$tj|du}|s dSt||kS)NF) importlibutil find_specr)rrpackage_existsrrr#rs rcCs*tjddup t}|sdSddl}dS)NmslkFrT)rrrrr)has_mslkrrrr#_is_mslk_availables rcs4eZdZdZddejdeejffdd ZZS)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. Nrbiascst||_||_dSrZ)superrcrr)rrrr(rr#rcs  zDummyModule.__init__rZ) rzrrrr4rr rc __classcell__rrrr#rs(r)rNN)T)FrZ)rN)r)r)JrrrrrArimportlib.metadatarmathrtypingrrr r4torch.nn.utils.parametrizer5rkrtorch.utils._python_dispatchr __all__cacher6r-r r r r]rrrfrrrrrrrrrrrrrrrrr;rCrFrMrVrWr'rrrrrrrrrrrrrrrrbrrrrrrr#s     G   7  # "# % !"