
    rh#                         d dl Z d dlmZmZ d dlZd dlmZ d dlmZ d dlm	Z	 d dl
mZmZmZmZmZ d dlmZ d dlmZmZmZ d	gZ G d
 d	e	      Zy)    N)OptionalUnion)Tensor)constraints)ExponentialFamily)broadcast_allclamp_probslazy_propertylogits_to_probsprobs_to_logits) binary_cross_entropy_with_logits)_Number_sizeNumberContinuousBernoullic                       e Zd ZdZej
                  ej                  dZej
                  ZdZ	dZ
	 	 	 	 d deeeef      deeeef      deeef   d	ee   d
df
 fdZd! fd	Zd Zd Zd Zd Zed
efd       Zed
efd       Zed
efd       Zed
efd       Zed
efd       Zed
ej@                  fd       Z! ej@                         fdZ" ej@                         fde#d
efdZ$d Z%d Z&d Z'd Z(ed
ee   fd       Z)d Z* xZ+S )"r   a  
    Creates a continuous Bernoulli distribution parameterized by :attr:`probs`
    or :attr:`logits` (but not both).

    The distribution is supported in [0, 1] and parameterized by 'probs' (in
    (0,1)) or 'logits' (real-valued). Note that, unlike the Bernoulli, 'probs'
    does not correspond to a probability and 'logits' does not correspond to
    log-odds, but the same names are used due to the similarity with the
    Bernoulli. See [1] for more details.

    Example::

        >>> # xdoctest: +IGNORE_WANT("non-deterministic")
        >>> m = ContinuousBernoulli(torch.tensor([0.3]))
        >>> m.sample()
        tensor([ 0.2538])

    Args:
        probs (Number, Tensor): (0,1) valued parameters
        logits (Number, Tensor): real valued parameters whose sigmoid matches 'probs'

    [1] The continuous Bernoulli: fixing a pervasive error in variational
    autoencoders, Loaiza-Ganem G and Cunningham JP, NeurIPS 2019.
    https://arxiv.org/abs/1907.06845
    )probslogitsr   TNr   r   limsvalidate_argsreturnc                 N   |d u |d u k(  rt        d      |t        |t              }t        |      \  | _        |A| j
                  d   j                  | j                        j                         st        d      t        | j                        | _        n&|J t        |t              }t        |      \  | _	        || j                  n| j                  | _
        |rt        j                         }n| j                  j                         }|| _        t        | A  ||       y )Nz;Either `probs` or `logits` must be specified, but not both.r   z&The parameter probs has invalid valuesr   )
ValueError
isinstancer   r   r   arg_constraintscheckallr	   r   _paramtorchSizesize_limssuper__init__)selfr   r   r   r   	is_scalarbatch_shape	__class__s          {/var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/torch/distributions/continuous_bernoulli.pyr%   zContinuousBernoulli.__init__7   s    TMv~.M  "5'2I)%0MTZ (++G4::4::FJJL$%MNN$TZZ0DJ%%%"673I*62NT[$)$5djj4;;**,K++**,K
MB    c                    | j                  t        |      }| j                  |_        t        j                  |      }d| j
                  v r1| j                  j                  |      |_        |j                  |_        d| j
                  v r1| j                  j                  |      |_	        |j                  |_        t        t        |/  |d       | j                  |_        |S )Nr   r   Fr   )_get_checked_instancer   r#   r    r!   __dict__r   expandr   r   r$   r%   _validate_args)r&   r(   	_instancenewr)   s       r*   r/   zContinuousBernoulli.expandW   s    (()<iHJJ	jj-dmm#

))+6CICJt}}$++K8CJCJ!30E0R!00
r+   c                 :     | j                   j                  |i |S N)r   r2   )r&   argskwargss      r*   _newzContinuousBernoulli._newe   s    t{{///r+   c                     t        j                  t        j                  | j                  | j                  d         t        j
                  | j                  | j                  d               S )Nr      )r    maxler   r#   gtr&   s    r*   _outside_unstable_regionz,ContinuousBernoulli._outside_unstable_regionh   sG    yyHHTZZA/$**djjQRm1T
 	
r+   c                     t        j                  | j                         | j                  | j                  d   t        j
                  | j                        z        S )Nr   )r    wherer>   r   r#   	ones_liker=   s    r*   
_cut_probszContinuousBernoulli._cut_probsm   sC    {{))+JJJJqMEOODJJ77
 	
r+   c           	      F   | j                         }t        j                  t        j                  |d      |t        j                  |            }t        j                  t        j
                  |d      |t        j                  |            }t        j                  t        j                  t        j                  |       t        j                  |      z
              t        j                  t        j                  |d      t        j                  d|z        t        j                  d|z  dz
              z
  }t        j                  | j                  dz
  d      }t        j                  d      dd|z  z   |z  z   }t        j                  | j                         ||      S )zLcomputes the log normalizing constant as a function of the 'probs' parameter      ?g              @      ?   gUUUUUU?g'}'}@)rB   r    r@   r;   
zeros_likegerA   logabslog1ppowr   mathr>   )r&   	cut_probscut_probs_below_halfcut_probs_above_halflog_normxtaylors          r*   _cont_bern_log_normz'ContinuousBernoulli._cont_bern_log_normt   s;   OO%	${{HHY$i1A1A)1L 
  %{{HHY$i1K 
 99IIekk9*-		)0DDE
KKHHY$KK334IIc00367

 IIdjj3&*#)lQ.>">!!CC{{488:HfMMr+   c                 D   | j                         }|d|z  dz
  z  dt        j                  |       t        j                  |      z
  z  z   }| j                  dz
  }dddt        j
                  |d      z  z   |z  z   }t        j                  | j                         ||      S )NrE   rF   rD   gUUUUUU?gll?rG   )rB   r    rL   rJ   r   rM   r@   r>   )r&   rO   musrS   rT   s        r*   meanzContinuousBernoulli.mean   s    OO%	3?S01CKK
#eii	&::5
 
 JJ	K%))Aq/$AAQFF{{488:CHHr+   c                 @    t        j                  | j                        S r4   )r    sqrtvariancer=   s    r*   stddevzContinuousBernoulli.stddev   s    zz$--((r+   c                    | j                         }||dz
  z  t        j                  dd|z  z
  d      z  dt        j                  t        j                  |       t        j                  |      z
  d      z  z   }t        j                  | j
                  dz
  d      }ddd|z  z
  |z  z
  }t        j                  | j                         ||      S )NrF   rE   rG   rD   gUUUUUU?g?ggjV?)rB   r    rM   rL   rJ   r   r@   r>   )r&   rO   varsrS   rT   s        r*   r[   zContinuousBernoulli.variance   s    OO%	IO,uyy#	/!10
 
%))EKK
3eii	6JJANNO IIdjj3&*zMA,==BB{{488:D&IIr+   c                 0    t        | j                  d      S NT)	is_binary)r   r   r=   s    r*   r   zContinuousBernoulli.logits   s    tzzT::r+   c                 B    t        t        | j                  d            S r`   )r	   r   r   r=   s    r*   r   zContinuousBernoulli.probs   s    ?4;;$GHHr+   c                 6    | j                   j                         S r4   )r   r"   r=   s    r*   param_shapezContinuousBernoulli.param_shape   s    {{!!r+   c                    | j                  |      }t        j                  || j                  j                  | j                  j
                        }t        j                         5  | j                  |      cd d d        S # 1 sw Y   y xY wN)dtypedevice)_extended_shaper    randr   rg   rh   no_gradicdfr&   sample_shapeshapeus       r*   samplezContinuousBernoulli.sample   sa    $$\2JJuDJJ$4$4TZZ=N=NO]]_ 	 99Q<	  	  	 s   &BB
rn   c                     | j                  |      }t        j                  || j                  j                  | j                  j
                        }| j                  |      S rf   )ri   r    rj   r   rg   rh   rl   rm   s       r*   rsamplezContinuousBernoulli.rsample   sF    $$\2JJuDJJ$4$4TZZ=N=NOyy|r+   c                     | j                   r| j                  |       t        | j                  |      \  }}t	        ||d       | j                         z   S )Nnone)	reduction)r0   _validate_sampler   r   r   rU   )r&   valuer   s      r*   log_probzContinuousBernoulli.log_prob   sR    !!%(%dkk59-fevNN&&()	
r+   c           
         | j                   r| j                  |       | j                         }t        j                  ||      t        j                  d|z
  d|z
        z  |z   dz
  d|z  dz
  z  }t        j
                  | j                         ||      }t        j
                  t        j                  |d      t        j                  |      t        j
                  t        j                  |d      t        j                  |      |            S )NrF   rE   g        )r0   rw   rB   r    rM   r@   r>   r;   rH   rI   rA   )r&   rx   rO   cdfsunbounded_cdfss        r*   cdfzContinuousBernoulli.cdf   s    !!%(OO%	IIi'%))C)OS5[*QQ 9_s"	$
 T%B%B%DdER{{HHUC U#KK,eooe.DnU
 	
r+   c           	      4   | j                         }t        j                  | j                         t        j                  | |d|z  dz
  z  z         t        j                  |       z
  t        j
                  |      t        j                  |       z
  z  |      S )NrE   rF   )rB   r    r@   r>   rL   rJ   )r&   rx   rO   s      r*   rl   zContinuousBernoulli.icdf   s    OO%	{{))+YJ#	/C2G)HHI++yj)* yy#ekk9*&==	?
 
 	
r+   c                     t        j                  | j                         }t        j                  | j                        }| j                  ||z
  z  | j                         z
  |z
  S r4   )r    rL   r   rJ   rX   rU   )r&   
log_probs0
log_probs1s      r*   entropyzContinuousBernoulli.entropy   sW    [[$**-
YYtzz*
IIj01&&()	
r+   c                     | j                   fS r4   )r   r=   s    r*   _natural_paramsz#ContinuousBernoulli._natural_params   s    ~r+   c                    t        j                  t        j                  || j                  d   dz
        t        j                  || j                  d   dz
              }t        j
                  ||| j                  d   dz
  t        j                  |      z        }t        j                  t        j                  t         j                  j                  |                  t        j                  t        j                  |            z
  }d|z  t        j                  |d      dz  z   t        j                  |d      dz  z
  }t        j
                  |||      S )zLcomputes the log normalizing constant as a function of the natural parameterr   rD   r9   rG   g      8@   g     @)r    r:   r;   r#   r<   r@   rA   rJ   rK   specialexpm1rM   )r&   rS   out_unst_regcut_nat_paramsrR   rT   s         r*   _log_normalizerz#ContinuousBernoulli._log_normalizer   s   yyHHQ

1+,ehhq$**Q-#:M.N
 !djjmc1U__Q5GG
 99IIemm)).9:
IIeii/01 q599Q?T11EIIaOf4LL{{<6::r+   )NN)gV-?gx&1?Nr4   ),__name__
__module____qualname____doc__r   unit_intervalrealr   support_mean_carrier_measurehas_rsampler   r   r   r   tuplefloatboolr%   r/   r7   r>   rB   rU   propertyrX   r\   r[   r
   r   r   r    r!   rd   rq   r   rs   ry   r}   rl   r   r   r   __classcell__)r)   s   @r*   r   r      s   4 !, 9 9[EUEUVO''GK 2626$2(,Cffn-.C vv~./C E5L!	C
  ~C 
C@0


N( If I I ) ) ) J& J J ; ; ; Iv I I "UZZ " " #-%**,   -7EJJL E V 


 


 v  ;r+   )rN   typingr   r   r    r   torch.distributionsr   torch.distributions.exp_familyr   torch.distributions.utilsr   r	   r
   r   r   torch.nn.functionalr   torch.typesr   r   r   __all__r    r+   r*   <module>r      sF     "   + <  A . . !
!^;+ ^;r+   