o
    ?Hh                     @   s   d Z ddlmZmZ ddlmZ ddlZddlm	Z	m
Z
 ddlmZ ddlmZ eG d	d
 d
ZejfddZG dd deZG dd deZG dd deZG dd deZG dd deZG dd deZeeeeedZdS )zM
Module contains classes for invertible (and differentiable) link functions.
    )ABCabstractmethod)	dataclassN)expitlogit)gmean   )softmaxc                   @   s>   e Zd ZU eed< eed< eed< eed< dd Zdd Zd	S )
Intervallowhighlow_inclusivehigh_inclusivec                 C   s*   | j | jkrtd| j  d| j ddS )zCheck that low <= highz#One must have low <= high; got low=z, high=.N)r   r   
ValueError)self r   R/home/air/sanwanet/gpt-api/venv/lib/python3.10/site-packages/sklearn/_loss/link.py__post_init__   s
   zInterval.__post_init__c                 C   sd   | j rt|| j}nt|| j}t|sdS | jr$t|| j}nt	|| j}t
t|S )zTest whether all values of x are in interval range.

        Parameters
        ----------
        x : ndarray
            Array whose elements are tested to be in interval range.

        Returns
        -------
        result : bool
        F)r   npgreater_equalr   greaterallr   
less_equalr   lessbool)r   xr   r   r   r   r   includes    s   
zInterval.includesN)__name__
__module____qualname__float__annotations__r   r   r   r   r   r   r   r
      s   
 r
   c                 C   s   dt |j }| jt j krd}n| jdk r!| jd|  | }n	| jd|  | }| jt jkr6d}||fS | jdk rH| jd|  | }||fS | jd|  | }||fS )zGenerate values low and high to be within the interval range.

    This is used in tests only.

    Returns
    -------
    low, high : tuple
        The returned values low and high lie within the interval.
    
   g    _r      g    _B)r   finfoepsr   infr   )intervaldtyper&   r   r   r   r   r   _inclusive_low_high=   s   


r*   c                   @   sD   e Zd ZdZdZeej ejddZe	dddZ
e	dddZdS )	BaseLinka   Abstract base class for differentiable, invertible link functions.

    Convention:
        - link function g: raw_prediction = g(y_pred)
        - inverse link h: y_pred = h(raw_prediction)

    For (generalized) linear models, `raw_prediction = X @ coef` is the so
    called linear predictor, and `y_pred = h(raw_prediction)` is the predicted
    conditional (on X) expected value of the target `y_true`.

    The methods are not implemented as staticmethods in case a link function needs
    parameters.
    FNc                 C      dS )aX  Compute the link function g(y_pred).

        The link function maps (predicted) target values to raw predictions,
        i.e. `g(y_pred) = raw_prediction`.

        Parameters
        ----------
        y_pred : array
            Predicted target values.
        out : array
            A location into which the result is stored. If provided, it must
            have a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned.

        Returns
        -------
        out : array
            Output array, element-wise link function.
        Nr   r   y_predoutr   r   r   linko       zBaseLink.linkc                 C   r,   )a  Compute the inverse link function h(raw_prediction).

        The inverse link function maps raw predictions to predicted target
        values, i.e. `h(raw_prediction) = y_pred`.

        Parameters
        ----------
        raw_prediction : array
            Raw prediction values (in link space).
        out : array
            A location into which the result is stored. If provided, it must
            have a shape that the inputs broadcast to. If not provided or None,
            a freshly-allocated array is returned.

        Returns
        -------
        out : array
            Output array, element-wise inverse link function.
        Nr   r   raw_predictionr/   r   r   r   inverse   r1   zBaseLink.inverseN)r   r   r    __doc__is_multiclassr
   r   r'   interval_y_predr   r0   r4   r   r   r   r   r+   Y   s    r+   c                   @   s   e Zd ZdZdddZeZdS )IdentityLinkz"The identity link function g(x)=x.Nc                 C   s   |d urt || |S |S r5   )r   copytor-   r   r   r   r0      s   zIdentityLink.linkr5   )r   r   r    r6   r0   r4   r   r   r   r   r9      s    
r9   c                   @   s4   e Zd ZdZedejddZd	ddZd	ddZ	dS )
LogLinkz"The log link function g(x)=log(x).r   FNc                 C      t j||dS Nr/   )r   logr-   r   r   r   r0         zLogLink.linkc                 C   r<   r=   )r   expr2   r   r   r   r4      r@   zLogLink.inverser5   )
r   r   r    r6   r
   r   r'   r8   r0   r4   r   r   r   r   r;      s
    
r;   c                   @   2   e Zd ZdZeddddZd
ddZd
dd	ZdS )	LogitLinkz&The logit link function g(x)=logit(x).r   r$   FNc                 C      t ||dS r=   r   r-   r   r   r   r0         zLogitLink.linkc                 C   rD   r=   r   r2   r   r   r   r4      rF   zLogitLink.inverser5   r   r   r    r6   r
   r8   r0   r4   r   r   r   r   rC      s
    
rC   c                   @   rB   )HalfLogitLinkzZHalf the logit link function g(x)=1/2 * logit(x).

    Used for the exponential loss.
    r   r$   FNc                 C   s   t ||d}|d9 }|S )Nr>   g      ?rE   r-   r   r   r   r0      s   zHalfLogitLink.linkc                 C   s   t d| |S )Nr   rG   r2   r   r   r   r4      r@   zHalfLogitLink.inverser5   rH   r   r   r   r   rI      s
    
rI   c                   @   s>   e Zd ZdZdZeddddZdd Zdd	d
ZdddZ	dS )MultinomialLogita  The symmetric multinomial logit function.

    Convention:
        - y_pred.shape = raw_prediction.shape = (n_samples, n_classes)

    Notes:
        - The inverse link h is the softmax function.
        - The sum is over the second axis, i.e. axis=1 (n_classes).

    We have to choose additional constraints in order to make

        y_pred[k] = exp(raw_pred[k]) / sum(exp(raw_pred[k]), k=0..n_classes-1)

    for n_classes classes identifiable and invertible.
    We choose the symmetric side constraint where the geometric mean response
    is set as reference category, see [2]:

    The symmetric multinomial logit link function for a single data point is
    then defined as

        raw_prediction[k] = g(y_pred[k]) = log(y_pred[k]/gmean(y_pred))
        = log(y_pred[k]) - mean(log(y_pred)).

    Note that this is equivalent to the definition in [1] and implies mean
    centered raw predictions:

        sum(raw_prediction[k], k=0..n_classes-1) = 0.

    For linear models with raw_prediction = X @ coef, this corresponds to
    sum(coef[k], k=0..n_classes-1) = 0, i.e. the sum over classes for every
    feature is zero.

    Reference
    ---------
    .. [1] Friedman, Jerome; Hastie, Trevor; Tibshirani, Robert. "Additive
        logistic regression: a statistical view of boosting" Ann. Statist.
        28 (2000), no. 2, 337--407. doi:10.1214/aos/1016218223.
        https://projecteuclid.org/euclid.aos/1016218223

    .. [2] Zahid, Faisal Maqbool and Gerhard Tutz. "Ridge estimation for
        multinomial logit models with symmetric side constraints."
        Computational Statistics 28 (2013): 1017-1034.
        http://epub.ub.uni-muenchen.de/11001/1/tr067.pdf
    Tr   r$   Fc                 C   s    |t j|ddd d t jf  S )Nr$   axis)r   meannewaxis)r   r3   r   r   r   symmetrize_raw_prediction  s    z*MultinomialLogit.symmetrize_raw_predictionNc                 C   s,   t |dd}tj||d d tjf  |dS )Nr$   rK   r>   )r   r   r?   rN   )r   r.   r/   gmr   r   r   r0     s    zMultinomialLogit.linkc                 C   s0   |d u r
t |ddS t|| t |dd |S )NT)copyF)r	   r   r:   r2   r   r   r   r4     s
   zMultinomialLogit.inverser5   )
r   r   r    r6   r7   r
   r8   rO   r0   r4   r   r   r   r   rJ      s    -
rJ   )identityr?   r   
half_logitmultinomial_logit)r6   abcr   r   dataclassesr   numpyr   scipy.specialr   r   scipy.statsr   utils.extmathr	   r
   float64r*   r+   r9   r;   rC   rI   rJ   _LINKSr   r   r   r   <module>   s,    *CC
