+ &jP0^RIt^RIHtHtHt^RIHt]R!,tR"RRllt R#RRllt R$RRllt R%R R llt R%R R llt R&R RlltR'RRlltR&RRlltR(RRlltR)RRlltR"RRlltR*RRlltR"RRlltR+RRlltR,RR lltR#)-N)LiteralOptionalget_argscDV^8dQhR\PR\/#)loss reductionmxarray Reduction)formats"e/Users/jameslopez/projects/CWCArchive/cwc-podcast/.venv/lib/python3.14/site-packages/mlx/nn/losses.py __annotate__r s  "(( y cV\\49d\R\\4 R24hVR8Xd\P!V4#VR8Xd\P !V4#VR8XdV#R#)z"Invalid reduction. Must be one of .meansumnoneN)rr ValueErrorr rr)rr s&&r_reducer si++=hy>Q=RRSTUUFwwt} e vvd| f   rcV^8dQhR\PR\PR\\P,R\R\R\ R\P/#)rlogitstargetsweightsaxislabel_smoothingr return)r r rintfloatr )rs"rrrsl^$^$ HH^$ XX^$bhh ^$  ^$  ^$  ^$XX^$rcV^8gV^8d\RV R24hVPVP8HpRpV'dVPVP8wg+V'gIVPV!VPV48wd'\RVP RVP R24hV'd \P!W,VR7pM;\P !V\P !W4V4PV4p\P!WR7p V^8d=^V, V,p VPVR7p V )V,p W, V ,p MW, p VeJVPV P8wd'\RVP RV P R24hW,p \W4#) a Computes the cross entropy loss. Args: logits (array): The unnormalized logits. targets (array): The ground truth values. These can be class indices or probabilities for each class. If the ``targets`` are class indices, then ``targets`` shape should match the ``logits`` shape with the ``axis`` dimension removed. If the ``targets`` are probabilities (or one-hot encoded), then the ``targets`` shape should be the same as the ``logits`` shape. weights (array, optional): Optional weights for each target. Default: ``None``. axis (int, optional): The axis over which to compute softmax. Default: ``-1``. label_smoothing (float, optional): Label smoothing factor. Default: ``0``. reduction (str, optional): Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``. Returns: array: The computed cross entropy loss. Examples: >>> import mlx.core as mx >>> import mlx.nn as nn >>> >>> # Class indices as targets >>> logits = mx.array([[2.0, -1.0], [-1.0, 2.0]]) >>> targets = mx.array([0, 1]) >>> nn.losses.cross_entropy(logits, targets) array([0.0485873, 0.0485873], dtype=float32) >>> >>> # Probabilities (or one-hot vectors) as targets >>> logits = mx.array([[2.0, -1.0], [-1.0, 2.0]]) >>> targets = mx.array([[0.9, 0.1], [0.1, 0.9]]) >>> nn.losses.cross_entropy(logits, targets) array([0.348587, 0.348587], dtype=float32) z$Label smoothing must in [0, 1), got rcP\V4pVPV4\V4#)N)listpoptuple)shapers&&r _drop_dim cross_entropy.._drop_dimIs U  $U|rzTargets shape z does not match logits shape rWeights with shape + is not the same as output loss with shape ) rndimr'r rtake_along_axis expand_dimssqueeze logsumexprr)rrrrrr targets_as_probsr(scorelogsumexp_logitsadjusted_score mean_logits smoothed_lossrs&&&&&& r cross_entropyr8sXo2??PPQRSS||v{{2 W]]fll: )FLL$2O!OW]]O+HVW X  v'd3""62>>'+H$OWW  ||F6o-6kktk, $ 6  0=@' ==DJJ &%gmm_5**.**Q8   4 ##rc V^8dQhR\PR\PR\\P,R\R\R\P/#)rinputsrr with_logitsr r)r r rboolr )rs"rrrxsY?$?$ HH?$ XX?$bhh ?$ ?$  ?$ XX ?$rcVPVP8wd'\RVP RVP R24hV'd&\P!RV4W,, pM\P!\P !V4R RR7p\P!\P !^V, 4R RR7pW,^V, V,,)pVeJVPVP8wd'\RVP RVP R24hWR,p\ WT4#) a Computes the binary cross entropy loss. By default, this function takes the pre-sigmoid logits, which results in a faster and more precise loss. For improved numerical stability when ``with_logits=False``, the loss calculation clips the input probabilities (in log-space) to a minimum value of ``-100``. Args: inputs (array): The predicted values. If ``with_logits`` is ``True``, then ``inputs`` are unnormalized logits. Otherwise, ``inputs`` are probabilities. targets (array): The binary target values in {0, 1}. with_logits (bool, optional): Whether ``inputs`` are logits. Default: ``True``. weights (array, optional): Optional weights for each target. Default: ``None``. reduction (str, optional): Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``. Returns: array: The computed binary cross entropy loss. Examples: >>> import mlx.core as mx >>> import mlx.nn as nn >>> logits = mx.array([0.105361, 0.223144, 1.20397, 0.916291]) >>> targets = mx.array([0, 0, 1, 1]) >>> loss = nn.losses.binary_cross_entropy(logits, targets, reduction="mean") >>> loss array(0.539245, dtype=float32) >>> probs = mx.array([0.1, 0.1, 0.4, 0.4]) >>> targets = mx.array([0, 0, 1, 1]) >>> loss = nn.losses.binary_cross_entropy(probs, targets, with_logits=False, reduction="mean") >>> loss array(0.510826, dtype=float32) Inputs shape  does not match targets shape rN)a_mina_maxr+r,i)r'rr logaddexpcliplogr)r:rrr;r rlog_inputs_cliplog_inputs_inv_clips&&&&& rbinary_cross_entropyrHxsT||w}}$FLL>)G VW X  ||C(6+;;''"&&.DI ggbffQZ&8DQ*a'k=P-PPQ ==DJJ &%gmm_5**.**Q8   4 ##rcV^8dQhR\PR\PR\R\P/#r predictionsrr rr )rs"rrr8$$$$&HH$9B$XX$rcVPVP8wd'\RVP RVP R24h\P!W, 4p\ W24#)a/ Computes the L1 loss. Args: predictions (array): The predicted values. targets (array): The target values. reduction (str, optional): Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``. Returns: array: The computed L1 loss. Predictions shape r?r)r'rr absrrKrr rs&&& rl1_lossrQsdGMM) !2!2 34$]]O1 .   66+' (D 4 ##rcV^8dQhR\PR\PR\R\P/#rJr )rs"rrrrLrcVPVP8wd'\RVP RVP R24h\P!W, 4p\ W24#)aO Computes the mean squared error loss. Args: predictions (array): The predicted values. targets (array): The target values. reduction (str, optional): Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``. Returns: array: The computed mean squared error loss. rNr?r)r'rr squarerrPs&&& rmse_lossrUsdGMM) !2!2 34$]]O1 .  99[* +D 4 ##rc V^8dQhR\PR\PR\R\R\P/#rr:rrr rr r r r )rs"rrrs@$$ HH$!xx$/2$DM$XX$rct\P!WR,V4PR4)p\WC4#)a Computes the negative log likelihood loss. Args: inputs (array): The predicted distribution in log space. targets (array): The target values. axis (int, optional): The distribution axis. Default: ``-1``. reduction (str, optional): Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``. Returns: array: The computed NLL loss. ).N)r r.r0rr:rrr rs&&&& rnll_lossr\s4   vy'94 @ H H L LD 4 ##rcV^8dQhR\PR\PR\PR\R\R\R\P/#)rr:rvarsfullepsr r)r r r<r!r )rs"rrrs^4$4$ HH4$ XX4$ ((4$  4$  4$  4$XX4$rcTVPVP8wd'\RVP RVP R24hVPVP8wd'\RVP RVP R24h\P!W$4pR\P!V4\P !W, 4V, ,,pV'd:VR\ P!^\ P,4,, p\We4#)a Computes the negative log likelihood loss for a Gaussian distribution. The loss is given by: .. math:: \frac{1}{2}\left(\log\left(\max\left(\text{vars}, \ \epsilon\right)\right) + \frac{\left(\text{inputs} - \text{targets} \right)^2} {\max\left(\text{vars}, \ \epsilon \right)}\right) + \text{const.} where ``inputs`` are the predicted means and ``vars`` are the the predicted variances. Args: inputs (array): The predicted expectation of the Gaussian distribution. targets (array): The target values (samples from the Gaussian distribution). vars (array): The predicted variance of the Gaussian distribution. full (bool, optional): Whether to include the constant term in the loss calculation. Default: ``False``. eps (float, optional): Small positive constant for numerical stability. Default: ``1e-6``. reduction (str, optional): Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``. Returns: array: The Gaussian NLL loss. r>r?rz does not match vars shape ?) r'rr maximumrErTmathpir)r:rr^r_r`r rs&&&&&& rgaussian_nll_lossrfsF||w}}$FLL>)G VW X  ||tzz!FLL>)DTZZLPQ R  ::d D "&&,7+;!>> import mlx.core as mx >>> import mlx.nn as nn >>> targets = mx.array([1, 1, -1]) >>> inputs1 = mx.array([-0.573409, -0.765166, -0.0638]) >>> inputs2 = mx.array([0.75596, 0.225763, 0.256995]) >>> loss = nn.losses.margin_ranking_loss(inputs1, inputs2, targets) >>> loss array(0.773433, dtype=float32) zPThe shapes of the arguments do not match. The provided shapes are inputs1.shape=z, inputs2.shape=z, and targets.shape=r)r'rr rcr)rrrrwr differencesrs&&&&& rmargin_ranking_lossr.sT MMW]] ;gmm ;$]]O+;GMM?K$]]O1 .  #K ::a'K/&8 9D 4 ##r)rrr)r)NrZr@r)NTr)r)rZr)Fư>r)?r)rZrrrr)rr)g:0yE>r)r@r)rdtypingrrrmlx.corecorer r rr8rHrQrUr\rfrjrqr|rrrrrrrrsw .. ) *  ^$B?$D$2$2$*4$n$6,$^'$T$2"$J$@!$H4$4$r