U ʹjz@sUddlZddlZddlZddlZddlZddlmZddlmZm Z m Z m Z ddl Z dcddZ ddddZded d Zd d Zd dZddZddZdfddZgZe ded<ddZddZddZeZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Z d)d*Z!d+d,Z"d-d.fd/d0Z#d1d2Z$d3d4Z%d5d6Z&d7d8Z'd9d:Z(d;d<Z)d=d>Z*d?d@Z+GdAdBdBe,Z-GdCdDdDZ.dEdFZ/dGdHZ0dIdJZ1dKdLZ2dMdNZ3e4dOdPdQZ5dgee6e6e4dRdSdTZ7dUdVZ8dWdXZ9GdYdZdZZ:d[d\Z;d]d^ZdS)hN) defaultdict)Any DefaultDictListOptionalFc Kstd||}|dkr&|jd|jjSt|tr8t|}|t|krH|S|jr|js\t d|j dd}|d|j}t j |||}|d}t j |||}||||S|jrt d||||S) aReturns the type if `dtype` is not provided, else casts this object to the specified type. If this is already of the correct type, no copy is performed and the original object is returned. Args: dtype (type or string): The desired type non_blocking (bool): If ``True``, and the source is in pinned memory and destination is on the GPU or vice versa, the copy is performed asynchronously with respect to the host. Otherwise, the argument has no effect. **kwargs: For compatibility, may contain the key ``async`` in place of the ``non_blocking`` argument. The ``async`` arg is deprecated. typeN.z)Cannot cast sparse tensor to dense tensorz.sparsez .LongTensorz)Cannot cast dense tensor to sparse tensor)_get_async_or_non_blocking __module__ __class____name__ isinstancestr_import_dotted_namer is_sparse RuntimeErrorreplacetorchTensor_values_indicessizecopy_) selfdtype non_blockingkwargsZnew_module_nameZnew_values_type_name new_valuesZnew_indices_type_nameZ new_indicesrK/var/www/html/bwave/python/venv/lib/python3.8/site-packages/torch/_utils.py_type s,    r!c Kstd||}ttdd}|dk s(td|jrP|dkr>|}||kr\|Sn |dkr\d}||D|jrvtdtj | tdd}| |||W5QRSQRXdS)aSReturns a copy of this object in HPU memory. If this object is already in HPU memory and on the correct device, then no copy is performed and the original object is returned. Args: device (int): The destination HPU id. Defaults to the current device. non_blocking (bool): If ``True`` and the source is in pinned memory, the copy will be asynchronous with respect to the host. Otherwise, the argument has no effect. **kwargs: For compatibility, may contain the key ``async`` in place of the ``non_blocking`` argument. hpuNzHPU device module is not loadedz/sparse storage is not supported for HPU tensorsdevice) r getattrrAssertionErrorZis_hpucurrent_device get_devicer%rUntypedStoragerr)rr%rrr"untyped_storagerrr _hpu4s     r,c Kstd||}|jr6|dkr$tj}||krB|Sn |dkrBd}tj||jrttjj |j j }tj |||}tj |||}||||W5QRStj|tdd}||||W5QRSW5QRXdS)aUReturns a copy of this object in CUDA memory. If this object is already in CUDA memory and on the correct device, then no copy is performed and the original object is returned. Args: device (int): The destination GPU id. Defaults to the current device. non_blocking (bool): If ``True`` and the source is in pinned memory, the copy will be asynchronous with respect to the host. Otherwise, the argument has no effect. **kwargs: For compatibility, may contain the key ``async`` in place of the ``non_blocking`` argument. cudaNr#r$)r Zis_cudarr-r(r)r%rr&sparser r rrrrr*r)rr%rrnew_typeindicesvaluesr+rrr _cudaTs(    r2cCsR|s|St|dksd|kr@d}t|}t|||td|dS)zReturn the non-blocking flag given the function name and kwargs. Args: function_name (str): the name of the function being used. non_blocking (bool): the default value. **kwargs (dict): the kwargs passed to the function. asyncz,{}() got an unexpected keyword argument '{}'z)'async' is deprecated; use 'non_blocking')lenlistkeyspop TypeErrorformatwarningswarn)Z function_namerrmessageargumentrrr r ys r cCs(tjg|j|jjd}||j|||SNrr%)rtensorrZ_untyped_storager%set_)storagestorage_offsetrstridetrrr _rebuild_tensorsrGcCst|tjsttj|SN)rrrr'_CZ_get_tensor_metadatarArrr get_tensor_metadatasrKcCs0t|tstt|tjsttj||dSrH)rdictr'rrrIZ_set_tensor_metadata)rAmetadatarrr set_tensor_metadatasrNcCs,t||||}||_|r"t||||_|SrH)rG requires_gradrN_backward_hooks)rCrDrrErObackward_hooksrMrArrr _rebuild_tensor_v2s  rRz torch.Tensor_sparse_tensors_to_validatecCsztD]}|jtjkr8t|||| q|jtj tj tj tj hkr|jtj tj hkrx||}}n||}}t|||||jqtd|jdqW5tXdS)Nz,_validate_loaded_sparse_tensors for layout ``)rSclearlayoutr sparse_cooZ _validate_sparse_coo_tensor_argsrrr is_coalesced sparse_csr sparse_csc sparse_bsr sparse_bscZ crow_indicesZ col_indicesZ ccol_indicesZ row_indicesZ'_validate_sparse_compressed_tensor_argsr1NotImplementedError)rFcompressed_indices plain_indicesrrr _validate_loaded_sparse_tensorssB  r`c Cs|tjkrTt|dkr&|\}}}d}n |\}}}}tj|||d|d}t||S|tjtjtjtj hkr|\}}}}tj |||||dd}t||St d|dS)z Rebuilds a sparse tensor from its sparse storage representation. Args: layout (str): The sparse storage layout of the tensor. data (tuple): The tensor's sparse storage representation. NF)check_invariantsrX)rVrbz$rebuilding sparse tensor for layout ) rrWr5Zsparse_coo_tensorrSappendrYrZr[r\Zsparse_compressed_tensorr]) rVdatar0r1rrXresultr^r_rrr _rebuild_sparse_tensors@       rfcCst|j||d}||_|Sr?)rZ from_numpytorO)rdrr%rOrArrr !_rebuild_device_tensor_from_numpy2srhcCstj|||d|dS)Nmeta)rr%rO)rZ empty_strided)rrrErOrrr _rebuild_meta_tensor_no_storage<srjc Cstjj|||||||dS)N)stridesrDrVr%rO)rrZ_make_wrapper_subclass)clsrrrErDrVr%rOrrr _rebuild_wrapper_subclassBsrmcCs|d}|tjkr6|\}} } tj|| | |j|jd} n|tjtjfkr|\}} } }t| tkrt| tkr|tjkrtj | tj |jd} tj | tj |jd} n(tj | tj |jd} tj | tj |jd} tj || | ||j|jd} ntd|| |||||| _|| _| S)Nr)scale zero_pointrr%r@)scales zero_pointsaxisrr%z0Can't deserialize quantized tensor with qscheme )rZper_tensor_affineZ_empty_affine_quantizedrr%Zper_channel_affineZ per_channel_affine_float_qparamsrr6rAdoublelongfloatZ#_empty_per_channel_affine_quantizedrrBrOrP)rCrDrrEZquantizer_paramsrOrQZqscheme_rnrorArprqrrrrr _rebuild_qtensorRsN      rwcCstj||}||_|SrH)rnn ParameterrP)rdrOrQparamrrr _rebuild_parametersr{cCs"tj||}||_t||}|SrH)rrxryrP_set_obj_state)rdrOrQstaterzrrr _rebuild_parameter_with_states r~csLtdd}|r|}n0tj}|rBjfdd|Df}nj}|S)N __getstate__cs"i|]}t|r|t|qSr)hasattrr&).0nameobjrr s z"_get_obj_state..)r&copyreg _slotnamesr __dict__)rZ getstate_fnr}Z slots_to_saverrr _get_obj_states    rcCst|tr6t|dks$td||d}|d}n|}d}|r`|D]\}}t|||qJ|r|D]\}}t|||ql|S)NzInvalid serialized state: rr3)rtupler5ritemssetattr)rr}Z dict_stateZ slots_statekvrrr r|s   r|cCs6|d}t|d}|ddD]}t||}q"|S)Nrrr3)split __import__r&)r componentsr componentrrr rs    rcCs||SrHr)xyrrr rccsPt|}z t|}Wntk r*YdSX|V|D]}|||}|Vq6dS)zReturn running totalsN)iternext StopIteration)iterablefnittotalelementrrr _accumulates  rcCstjj|S)aFlatten dense tensors into a contiguous 1D buffer. Assume tensors are of same dense type. Since inputs are dense, the resulting tensor will be a concatenated 1D buffer. Element-wise operation on this buffer will be equivalent to operating individually. Args: tensors (Iterable[Tensor]): dense tensors to flatten. Returns: A contiguous 1D buffer containing input tensors. rrI_nnZflatten_dense_tensors)tensorsrrr _flatten_dense_tensorssrcCs8tjjdd|D}tjjdd|D}||fS)abFlatten sparse tensors into two contiguous 1D buffers, one of indices and one of values. Assume tensors are of same sparse type. Args: tensors (Iterable[Tensor]): sparse tensors to flatten. Returns: A tuple of two contiguous 1D buffers, one containing input tensors' indices and the other containing the values. cSsg|]}tj|qSrrrrrrFrrr sz+_flatten_sparse_tensors..cSsg|]}tj|qSrrrrrrrr rsr)r flat_indices flat_valuesrrr _flatten_sparse_tensorss   rcCstjj||S)aView a flat buffer using the sizes of tensors. Assume that tensors are of same dense type, and that flat is given by _flatten_dense_tensors. Args: flat (Tensor): flattened dense tensors to unflatten. tensors (Iterable[Tensor]): dense tensors whose sizes will be used to unflatten flat. Returns: Unflattened dense tensors with sizes same as tensors and values from flat. )rrIrunflatten_dense_tensors)flatrrrr _unflatten_dense_tensors s rc Csx|\}}tjj|dd|D}tjj|dd|D}g}t|||D]"\}}} |||| |qLt|S)aView flat buffer (containing indices and values) using the sizes of tensors. Assume that tensors are of same sparse type, and that flat is given by _flatten_sparse_tensors. Args: flat (tuple(Tensor, Tensor)): flattened indices and values of sparse tensors to unflatten. tensors (Iterable[Tensor]): sparse tensors whose sizes will be used to unflatten flat. Returns: Unflattened sparse tensors with sizes same as tensors and values from flat. cSsg|]}tj|qSrrrrrr r*sz-_unflatten_sparse_tensors..cSsg|]}tj|qSrrrrrr r-s) rrIrrziprcnewrr) rrrrr0r1outputsrFirrrr _unflatten_sparse_tensorss  rcsLtt}|D]}|||q dd|Dtfdd|DS)aAssume that tensors are of same order as ordered_tensors within their types, e.g., from _take_tensors. Reorder them to be of same order as ordered_tensors. Args: tensors (Iterable[Tensor]): tensors to be reordered. They should be of the same order as ordered_tensors within their own types. ordered_tensors (Iterable[Tensor]): tensors whose order will be the reference. Returns: Ordered tuple of tensors with contents from tensors and order of ordered_tensors. cSsi|]\}}|t|qSr)r)rrFZcollrrr rGsz'_reorder_tensors_as..c3s|]}t|VqdSrH)rr)rrAZ type_dict_rr Hsz&_reorder_tensors_as..)rr6rrcrr)rZordered_tensorsZ type_dictrArrr _reorder_tensors_as5s rc cstdd}|D]}|}|jr\tj|}tj|}||||}n||}||}|d||kr|ddkr|dVgdg}||<|d ||d|7<q| D]\} } t | dkr| VqdS)aGroup tensors into chunks. This generator yields a chunk at each time, each containing tensors of same type up to certain byte limit in total size. Args: tensors (Sequence): A sequence of tensors to be separated into chunks. size_limit (int): The limit of each chunk in bytes. Yields: Blocks of tensors of same type and within size_limit. The yielded tensors are only ordered as the original sequence within its types. cSsgdgS)Nrrrrrr rWrz_take_tensors..r3rN) rrrrrrrZnumelZ element_sizercr1r5) rZ size_limitZbuf_dictrArFr0r1rZ buf_and_sizebufrvrrr _take_tensorsKs(     rc sfdd}|S)Ncst|_|jd<|S)Nreturn)rL__annotations__)Zfunrretrr decqs  zannotate..decr)rrrrrr annotatepsrc Cstj|}|dkrt|}g}tjjdddH|dd|D|dd|D|dd|d}W5QRX|S) Nr) thresholdZ edgeitemscss|]}t|VqdSrHrepr)rarrr rszrender_call..css$|]\}}|dt|VqdS)=Nr)rrrrrr rs(z, )) rZ overrides resolve_namerZ _tensor_strZ printoptionsextendrjoin)rargsrZstr_fnZstr_argsrrrr render_callys  rc@seZdZdZddZdS)KeyErrorMessagez(str subclass that returns itself in reprcCs|SrHr)rrrr __repr__szKeyErrorMessage.__repr__N)r r __qualname____doc__rrrrr rsrc@s"eZdZdZdddZddZdS) ExceptionWrapperz?Wraps an exception plus traceback to communicate across threadsN in backgroundcCs6|dkrt}|d|_dtj||_||_dS)Nrr )sysexc_infoexc_typer tracebackformat_exceptionexc_msgwhere)rrrrrr __init__s  zExceptionWrapper.__init__cCsd|jjd|jd|j}|jtkr2t|}nt|jddrL|j|dz||}Wntk rxt|dYnX|dS)z4Reraises the wrapped exception in the current threadzCaught  z . Original r=N)r=) rr rrKeyErrorrr&r9r)rmsg exceptionrrr reraises   zExceptionWrapper.reraise)Nr)r r rrrrrrrr rs rcCsPtjrdSttdr&tjr&dStj}tt|d}|rL|rL|SdSNr-xpu)rr-Z is_availablerrrI_get_privateuse1_backend_namer&)Zcustom_backend_nameZcustom_device_modrrr _get_available_device_types    rcCsZt}|r |dkr |tjS|r:|dkr:|tjS|tjkrV|tt|SdSr)rlowerrr-rrIrr&)Z get_member device_typerrr _get_device_attrs  rcCs tddS)NcSs|SrH)r(mrrr rrz+_get_current_device_index..rrrrr _get_current_device_indexsrcCs tddS)NcSstt|SrH)r6range device_countrrrr rrz)_get_all_device_indices..rrrrr _get_all_device_indicessrcCsdd|DS)Ncsg|]tfddqS)cs |SrH)Zget_device_propertiesrrrr rrz4_get_devices_properties...r)rrrr rsz+_get_devices_properties..r)Z device_idsrrr _get_devices_propertiessr)rcCstjdkrtjSdS)zChecks if there are CUDA devices available and returns the device index of the current default CUDA device. Returns -1 in case there are no CUDA devices available. Arguments: ``None`` rr#)rr-rr(rrrr get_current_device_indexs r)r%optional allow_cpurcCst|trt|}d}t|tjrT|s@|jdkr@td||jdkrNdn|j}t|trb|}|dkr|rtj rt }qt }ntd||S)a'Gets the device index from :attr:`device`, which can be a torch.device object, a Python integer, or ``None``. If :attr:`device` is a torch.device object, returns the device index if it has index. Note that for a device without a specified index, i.e., ``torch.device('xxx')``, this will return the current default device of that type if :attr:`optional` is ``True``. If :attr:`allow_cpu` is ``True``, CPU devices will be accepted and ``-1`` will be returned in this case. If :attr:`device` is a Python integer, it is returned as is. If :attr:`device` is ``None``, this will return the current default device of the supported runtime platform if :attr:`optional` is ``True``. i.e., the current default CUDA device will be returned if CUDA runtime is supported. Ncpuz$Expected a non cpu device, but got: r#zFExpected a torch.device with a specified index or an integer, but got:) rrrr%r ValueErrorindexintZjitZ is_scriptingrr)r%rrZ device_idxrrr _get_device_indexs$     rcCs$t|tjjs |r t|S|S)z Returns a real view of a tensor if complex dtype else just the tensor need to check if a UninitializedParameter because otherwise checking is_complex is an error for a LazyModule )rrrxZUninitializedParameter is_complexZ view_as_realrJrrr _handle_complexs   rcCslt|tjstdt||jr4t|jd?S|jrJt|jd?S|tj krXdSt |jd?SdS)z8 Returns the element size for a dtype, in bytes zexpected torch.dtype, but got rrar3N) rrrrrrZfinfobitsZis_floating_pointboolZiinfo)rrrr _element_size&s  rc@s eZdZdddZdddZdS)_ClassPropertyDescriptorNcCs ||_dSrH)fget)rrfsetrrr r9sz!_ClassPropertyDescriptor.__init__cCs |dkrt|}|j||SrH)rr__get__)rinstanceownerrrr r<sz _ClassPropertyDescriptor.__get__)N)N)r r rrrrrrr r8s rcCst|ttfst|}t|SrH)r classmethod staticmethodr)funcrrr classpropertyBsrcCsdS)NFrrrrr is_compilingIsrr)rcCs.tt|d}|dkr*td|d|d|S)NzDevice 'z<' does not have a corresponding module registered as 'torch.z'.)r&rr)rZ device_modulerrr _get_device_moduleMs  r)NF)NF)NF)N)FF)?r functoolsrrr; collectionsrtypingrrrrrr!r,r2r rGrKrNrRrSrr`rfrhZ_rebuild_xla_tensorrjrmrwr{r~rr|rrrrrrrrrrrrrrrrrrrrrrrrrrr lru_cacherrrrr s|  ( %9  %*3   % #    -