o X۷i8@sddlmZddlZddlZddlmZddlmZddlmZddl m Z d!d d Z d"ddZ ej ddddZddZddZd#ddZddZd#ddZdd ZdS)$) annotationsN)device)runtime)_util)_dtypedtypenumpy.dtype | strreturnNonecCs&t|tjr |j}|dvrtddS)NfdFD>Only float32, float64, complex64, and complex128 are supported) isinstancenumpyrchar RuntimeErrorrrM/home/ubuntu/vllm_env/lib/python3.10/site-packages/cupy/linalg/_eigenvalue.py _check_dtype s rFcCslddlm}ddlm}|dvrtdtj|dd\}}|j}|j} |j|d| d } |j \} } t | |} t d t j }tj}|rM|j}n|j}|d krX|j}n|j}tjst|t|}t|}|}zF|||||| || jj| || jj| \}}t |d }t |d }|||||| || jj| || jj||jj||jj||jjW| |n| |wt j!j"|j|na|d kr|j#}|j$}n%|dkr|j%}|j&}n|dkr|j'}|j(}n|dkr|j)}|j*}nt+d||||| | jj| | jj}t ||}||||| | jj| | jj|jj||jj t j!j"||| j| dd| j|ddfS)Nr)cublascusolver)LUz UPLO argument must be 'L' or 'U'F)reject_float16FordercopyrrbfdDr )r),cupy_backends.cuda.libsrr ValueErrorrlinalg_common_typerlowerastypeshapecupyemptyrint32rDevicecusolver_handleCUSOLVER_EIG_MODE_VECTORCUSOLVER_EIG_MODE_NOVECTORCUBLAS_FILL_MODE_LOWERCUBLAS_FILL_MODE_UPPERris_hiprr to_cuda_dtype createParamsxsyevd_bufferSizedataptrxsyevdctypes destroyParamslinalg3_check_cusolver_dev_info_if_synchronization_allowedssyevd_bufferSizessyevddsyevd_bufferSizedsyevdcheevd_bufferSizecheevdzheevd_bufferSizezheevdr)aUPLOwith_eigen_vector overwrite_arrrv_dtype real_dtypew_dtypevmldawdev_infohandlejobzuplotype_vtype_wparamswork_device_sizework_host_sizse work_device work_host buffer_sizesyevd work_sizeworkrrr_syevds              r_zuint64 n, raw C w, raw R v_realzraw C v_complexa int col_idx = i % n; auto ew_i = w[col_idx].imag(); // if img == 0 -> ev = ev[i] // if img positive -> ev = ev[i] + i*ev[i+1] // if img negative -> ev = ev[i-1] - i*ev[i] int real_idx = i - ((ew_i < 0) ? 1 : 0); int img_idx = i + ((ew_i > 0) ? 1 : 0); R factor = ((ew_i > 0) ? R(1.0) : ((ew_i < 0) ? R(-1.0) : R(0.0))); v_complex[i].real(v_real[real_idx]); v_complex[i].imag(factor * v_real[img_idx]); cupy_assemble_complex_evs_kernelcCs&t|}t|||||d}||S)N)size)len_assemble_complex_evs_kernelreshape)rOv_realr(n v_complexrrr_assemble_complex_evsxs rhcCs4ddlm}ddlm}ddlm}|dstdtjr!t dt |\}}t |t |j}t|dd jd d }||jkrM|j|d d d }n|}|jdd\} } tj|jdd |d} tj||d} ||k} | r{tj| | f|dd}tdt j}tj}|r|j}n|j}|j}t|}t|}| }z| r|n| }|!||||| ||j"j#| || j"j#||j"j#| ||j"j#| |\}}t|d}||d}t$|jdkr/t %|jddD]I}||}| |}| r|n| |}|&||||| ||j"j#| ||j"j#||j"j#| ||j"j#| ||j"j#||j'j"||j"j#| r-|r-t(|||j| |<qn5|&||||| ||j"j#| || j"j#||j"j#| ||j"j#| ||j"j#||j'j"||j"j#| rd|rdt(| ||j} W|)|n|)|wtj*j +|j&|t|dd jd d }|r| st| dd jd d } | | fS)Nrr)check_availability) empty_pinnedgeevzgeev is not availablezgeev is not implemented for HIPC)rTrrr)rrrr),r#rcupyx.cusolverricupyxrjrrr2NotImplementedErrorrr%rrrrupperr)swapaxesrr'r(r* empty_liker+rr,r-r.r/rr3r4xgeev_bufferSizer6r7rbndindexxgeevr9rhr:r;r<)rErGrrirj input_dtype_ complex_dtypea_rMrNrOrL real_inputrerPrQjobvrjobvl type_complex type_inputrVv_rWwork_host_sizerYrZinda_indw_indv_indrrr_geev~s                  rrcCsddl}t|t||jdkr5t|\}}|j}t |j dd|}t |j |}||fS|j dks=t j rK|j||d\}}||fSt||dS)a Return the eigenvalues and eigenvectors of a complex Hermitian (conjugate symmetric) or a real symmetric matrix. Returns two objects, a 1-D array containing the eigenvalues of `a`, and a 2-D square array or matrix (depending on the input type) of the corresponding eigenvectors (in columns). Args: a (cupy.ndarray): A symmetric 2-D square matrix ``(M, M)`` or a batch of symmetric 2-D square matrices ``(..., M, M)``. UPLO (str): Select from ``'L'`` or ``'U'``. It specifies which part of ``a`` is used. ``'L'`` uses the lower triangular part of ``a``, and ``'U'`` uses the upper triangular part of ``a``. Returns: tuple of :class:`~cupy.ndarray`: Returns a tuple ``(w, v)``. ``w`` contains eigenvalues and ``v`` contains eigenvectors. ``v[:, i]`` is an eigenvector corresponding to an eigenvalue ``w[i]``. For batch input, ``v[k, :, i]`` is an eigenvector corresponding to an eigenvalue ``w[k, i]`` of ``a[k]``. .. warning:: This function calls one or more cuSOLVER routine(s) which may yield invalid results if input conditions are not met. To detect these invalid results, you can set the `linalg` configuration to a value that is not `ignore` in :func:`cupyx.errstate` or :func:`cupyx.seterr`. .. seealso:: :func:`numpy.linalg.eigh` rNrmroTrpr_assert_stacked_2d_assert_stacked_squarerar%rr&r)r*r(ndimrr2rsyevjr_)rErFrqrzrIrKrOrLrrreighs     rcCsbt|t||jdkr,t|\}}t|jdd|}t|j|}||fSt|dS)a  Return the eigenvalues and eigenvectors of a matrix. Returns two objects, a 1-D array containing the eigenvalues of `a`, and a 2-D square array or matrix (depending on the input type) of the corresponding eigenvectors (in columns). Args: a (cupy.ndarray): A symmetric 2-D square matrix ``(M, M)`` or a batch of symmetric 2-D square matrices ``(..., M, M)``. Returns: tuple of :class:`~cupy.ndarray`: Returns a tuple ``(w, v)``. ``w`` contains eigenvalues and ``v`` contains eigenvectors. ``v[:, i]`` is an eigenvector corresponding to an eigenvalue ``w[i]``. For batch input, ``v[k, :, i]`` is an eigenvector corresponding to an eigenvalue ``w[k, i]`` of ``a[k]``. Notes: There is no guarantee of the order of the eigenvalues: it can even be different from ``numpy.linalg.eig``. .. warning:: This function calls one or more cuSOLVER routine(s) which may yield invalid results if input conditions are not met. To detect these invalid results, you can set the `linalg` configuration to a value that is not `ignore` in :func:`cupyx.errstate` or :func:`cupyx.seterr`. .. seealso:: :func:`numpy.linalg.eig` rNrmT rrrrar%r)r*r(r)rErzrIrOrLrrreigs    rcCsddl}t|t||jdkr*t|\}}|j}t |j dd|S|j dks2t j r:|j||dSt||ddS)a- Compute the eigenvalues of a complex Hermitian or real symmetric matrix. Main difference from eigh: the eigenvectors are not computed. Args: a (cupy.ndarray): A symmetric 2-D square matrix ``(M, M)`` or a batch of symmetric 2-D square matrices ``(..., M, M)``. UPLO (str): Select from ``'L'`` or ``'U'``. It specifies which part of ``a`` is used. ``'L'`` uses the lower triangular part of ``a``, and ``'U'`` uses the upper triangular part of ``a``. Returns: cupy.ndarray: Returns eigenvalues as a vector ``w``. For batch input, ``w[k]`` is a vector of eigenvalues of matrix ``a[k]``. .. warning:: This function calls one or more cuSOLVER routine(s) which may yield invalid results if input conditions are not met. To detect these invalid results, you can set the `linalg` configuration to a value that is not `ignore` in :func:`cupyx.errstate` or :func:`cupyx.seterr`. .. seealso:: :func:`numpy.linalg.eigvalsh` rNrmroFr)rErFrqrzrIrKrrreigvalsh=s    rcCsTt|t||jdkr#t|\}}t|jdd|}|St|ddS)a Compute the eigenvalues of a matrix. Main difference from eig: the eigenvectors are not computed. Args: a (cupy.ndarray): A symmetric 2-D square matrix ``(M, M)`` or a batch of symmetric 2-D square matrices ``(..., M, M)``. Returns: cupy.ndarray: Returns eigenvalues as a vector ``w``. For batch input, ``w[k]`` is a vector of eigenvalues of matrix ``a[k]``. Notes: There is no guarantee of the order of the eigenvalues: it can even be different from ``numpy.linalg.eigvals``. .. warning:: This function calls one or more cuSOLVER routine(s) which may yield invalid results if input conditions are not met. To detect these invalid results, you can set the `linalg` configuration to a value that is not `ignore` in :func:`cupyx.errstate` or :func:`cupyx.seterr`. .. seealso:: :func:`numpy.linalg.eigvals` rNrmFr)rErzrIrOrrreigvalsfs   r)rrr r )F)r) __future__rrr) cupy.cudarr cupy.linalgr cupy._corerrr__coreElementwiseKernelrcrhrrrrrrrrrs(       P  b2 + )