L i+9ddlZddlmZmZmZmZmZmZddl m Z gdZ eddZ dZddd Zd Zd Zedd Zedd Zy)N)array_namespacexp_capabilities xp_devicexp_size xp_promotexp_float_to_complex)array_api_extra) logsumexpsoftmax log_softmaxc.t||}t||dd|\}}tj|d|}|tj|d|n|}|t t |j n|}t|dk7rtjddd5||j|n||j|z}|j||d }|r t|| nd}|r|j|n|}|j|} dddtjdd 5t||||| \} } ddd|j! } |j#| |  } |r|j#|  n } nqtj$|j&} d| |<|j)t | |j* |j,t/| } |j1| } |j3| j,dr|rA|j5| }t7t9|j;| | | }||dzz} n@|j5| }t7t9|j;| | | }||dzz} |s|j=| |n| } | |s|j=| |n| } | j dk(r| dn| } | | j dk(r| dn| } |r| | fS| S#1swYxYw#1swYxYw)a Compute the log of the sum of exponentials of input elements. Parameters ---------- a : array_like Input array. axis : None or int or tuple of ints, optional Axis or axes over which the sum is taken. By default `axis` is None, and all elements are summed. .. versionadded:: 0.11.0 b : array-like, optional Scaling factor for exp(`a`) must be of the same shape as `a` or broadcastable to `a`. These values may be negative in order to implement subtraction. .. versionadded:: 0.12.0 keepdims : bool, optional If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the original array. .. versionadded:: 0.15.0 return_sign : bool, optional If this is set to True, the result will be a pair containing sign information; if False, results that are negative will be returned as NaN. Default is False (no sign information). .. versionadded:: 0.16.0 Returns ------- res : ndarray The result, ``np.log(np.sum(np.exp(a)))`` calculated in a numerically more stable way. If `b` is given then ``np.log(np.sum(b*np.exp(a)))`` is returned. If ``return_sign`` is True, ``res`` contains the log of the absolute value of the argument. sgn : ndarray If ``return_sign`` is True, this will be an array of floating-point numbers matching res containing +1, 0, -1 (for real-valued inputs) or a complex phase (for complex inputs). This gives the sign of the argument of the logarithm in ``res``. If ``return_sign`` is False, only one result is returned. See Also -------- :data:`numpy.logaddexp` :data:`numpy.logaddexp2` Notes ----- NumPy has a logaddexp function which is very similar to `logsumexp`, but only handles two arguments. `logaddexp.reduce` is similar to this function, but may be less stable. The logarithm is a multivalued function: for each :math:`x` there is an infinite number of :math:`z` such that :math:`exp(z) = x`. The convention is to return the :math:`z` whose imaginary part lies in :math:`(-pi, pi]`. Examples -------- >>> import numpy as np >>> from scipy.special import logsumexp >>> a = np.arange(10) >>> logsumexp(a) 9.4586297444267107 >>> np.log(np.sum(np.exp(a))) 9.4586297444267107 With weights >>> a = np.arange(10) >>> b = np.arange(10, 0, -1) >>> logsumexp(a, b=b) 9.9170178533034665 >>> np.log(np.sum(b*np.exp(a))) 9.9170178533034647 Returning a sign flag >>> logsumexp([1,2],b=[1,-1],return_sign=True) (1.5413248546129181, -1.0) Notice that `logsumexp` does not directly support masked arrays. To use it on a masked array, convert the mask into zero weights: >>> a = np.ma.array([np.log(2), 2, np.log(3)], ... mask=[False, True, False]) >>> b = (~a.mask).astype(int) >>> logsumexp(a.data, b=b), np.log(5) 1.6094379124341005, 1.6094379124341005 T) broadcastforce_floatingxp)ndimrNrignore)divideinvalidoveraxiskeepdimsr)rr)r return_signr)dtypedevicecomplex floating?r)rrxpx atleast_ndtuplerangerrnperrstateexpsum_signabslog _logsumexpisfinitewhereasarrayshapefullinfrrsignisdtyperealr _wrap_radiansimagsqueeze)arbrrrb_exp_asum_sgn_infout_infoutsgn out_finiter1r6r8s ^/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/scipy/special/_logsumexp.pyr r s~ A B ad4B GDAq qqR(A,-MqqR(qA#'<5qvv TDqzQ [[( J #$%9bffQi!bffQi-G66't6A aAaC A A" aB /C zz!''?+ HHQVaR!VQ ' FF1IBFF2775>D011 ((1+q !E )Cggcl 8O CII /ffSk#'"&&rvv. 8OrJct|}|j|}|j||d}|j||z }||j ||dz S)a Compute the softmax function. The softmax function transforms each element of a collection by computing the exponential of each element divided by the sum of the exponentials of all the elements. That is, if `x` is a one-dimensional numpy array:: softmax(x) = np.exp(x)/sum(np.exp(x)) Parameters ---------- x : array_like Input array. axis : int or tuple of ints, optional Axis to compute values along. Default is None and softmax will be computed over the entire array `x`. Returns ------- s : ndarray An array the same shape as `x`. The result will sum to 1 along the specified axis. Notes ----- The formula for the softmax function :math:`\sigma(x)` for a vector :math:`x = \{x_0, x_1, ..., x_{n-1}\}` is .. math:: \sigma(x)_j = \frac{e^{x_j}}{\sum_k e^{x_k}} The `softmax` function is the gradient of `logsumexp`. The implementation uses shifting to avoid overflow. See [1]_ for more details. .. versionadded:: 1.2.0 References ---------- .. [1] P. Blanchard, D.J. Higham, N.J. Higham, "Accurately computing the log-sum-exp and softmax functions", IMA Journal of Numerical Analysis, Vol.41(4), :doi:`10.1093/imanum/draa038`. Examples -------- >>> import numpy as np >>> from scipy.special import softmax >>> np.set_printoptions(precision=5) >>> x = np.array([[1, 0.5, 0.2, 3], ... [1, -1, 7, 3], ... [2, 12, 13, 3]]) ... Compute the softmax transformation over the entire array. >>> m = softmax(x) >>> m array([[ 4.48309e-06, 2.71913e-06, 2.01438e-06, 3.31258e-05], [ 4.48309e-06, 6.06720e-07, 1.80861e-03, 3.31258e-05], [ 1.21863e-05, 2.68421e-01, 7.29644e-01, 3.31258e-05]]) >>> m.sum() 1.0 Compute the softmax transformation along the first axis (i.e., the columns). >>> m = softmax(x, axis=0) >>> m array([[ 2.11942e-01, 1.01300e-05, 2.75394e-06, 3.33333e-01], [ 2.11942e-01, 2.26030e-06, 2.47262e-03, 3.33333e-01], [ 5.76117e-01, 9.99988e-01, 9.97525e-01, 3.33333e-01]]) >>> m.sum(axis=0) array([ 1., 1., 1., 1.]) Compute the softmax transformation along the second axis (i.e., the rows). >>> m = softmax(x, axis=1) >>> m array([[ 1.05877e-01, 6.42177e-02, 4.75736e-02, 7.82332e-01], [ 2.42746e-03, 3.28521e-04, 9.79307e-01, 1.79366e-02], [ 1.22094e-05, 2.68929e-01, 7.31025e-01, 3.31885e-05]]) >>> m.sum(axis=1) array([ 1., 1., 1.]) Tr)rr0rMr(r))rGrrx_max exp_x_shifteds rCr r s\x  B 1 A FF14$F /EFF1u9%M 266-dT6J JJrJct|}|j|}|j||d}|jdkDr6t j ||j |jd}n|j |sd}||z }|j|}tjd5|j||d}|j|}ddd||z S#1swY|z SxYw)aCompute the logarithm of the softmax function. In principle:: log_softmax(x) = log(softmax(x)) but using a more accurate implementation. Parameters ---------- x : array_like Input array. axis : int or tuple of ints, optional Axis to compute values along. Default is None and softmax will be computed over the entire array `x`. Returns ------- s : ndarray or scalar An array with the same shape as `x`. Exponential of the result will sum to 1 along the specified axis. If `x` is a scalar, a scalar is returned. Notes ----- `log_softmax` is more accurate than ``np.log(softmax(x))`` with inputs that make `softmax` saturate (see examples below). .. versionadded:: 1.5.0 Examples -------- >>> import numpy as np >>> from scipy.special import log_softmax >>> from scipy.special import softmax >>> np.set_printoptions(precision=5) >>> x = np.array([1000.0, 1.0]) >>> y = log_softmax(x) >>> y array([ 0., -999.]) >>> with np.errstate(divide='ignore'): ... y = np.log(softmax(x)) ... >>> y array([ 0., -inf]) Trrr)rN) rr0rMrr"rPr.rQr(r&r'r)r,)rGrrretmpexp_tmprcr@s rCr r dsh  B 1 A FF14$F /E zzA~ur{{511266q9 [[  e)CffSkG H % FF7F 5ffQi 9  9s 5&C((C5)NNFF)N)numpyr&scipy._lib._array_apirrrrrr scipy._libr r"__all__r r7rWr*r-r r r!rJrCrns. 1N.N.b)46@/1h_K_KDEErJ