6biB SrSSKJs Jr SSKJr SSKJr SSK J r SSK J r \ "S/S9"S S 55r SS jrSS jrS rSr\ R$4Sjr\ "S/S9S\ R$S4Sj5rSrSrSrSrSrg)z$Utilities related to loss functions.N)backend) keras_tensor)tf_utils) keras_exportzkeras.losses.Reduction)v1cH\rSrSrSrSrSrSrSr\ S5r \ S5r S r g ) ReductionV2aTypes of loss reduction. Contains the following values: * `AUTO`: Indicates that the reduction option will be determined by the usage context. For almost all cases this uses `SUM_OVER_BATCH_SIZE`. When used with `tf.distribute.Strategy`, outside of built-in training loops such as `tf.keras` `compile` and `fit`, we expect reduction value to be `SUM` or `NONE`. Using `AUTO` in that case will raise an error. * `NONE`: No **additional** reduction is applied to the output of the wrapped loss function. When non-scalar losses are returned to Keras functions like `fit`/`evaluate`, the unreduced vector loss is passed to the optimizer but the reported loss will be a scalar value. Caution: **Verify the shape of the outputs when using** `Reduction.NONE`. The builtin loss functions wrapped by the loss classes reduce one dimension (`axis=-1`, or `axis` if specified by loss function). `Reduction.NONE` just means that no **additional** reduction is applied by the class wrapper. For categorical losses with an example input shape of `[batch, W, H, n_classes]` the `n_classes` dimension is reduced. For pointwise losses you must include a dummy axis so that `[batch, W, H, 1]` is reduced to `[batch, W, H]`. Without the dummy axis `[batch, W, H]` will be incorrectly reduced to `[batch, W]`. * `SUM`: Scalar sum of weighted losses. * `SUM_OVER_BATCH_SIZE`: Scalar `SUM` divided by number of elements in losses. This reduction type is not supported when used with `tf.distribute.Strategy` outside of built-in training loops like `tf.keras` `compile`/`fit`. You can implement 'SUM_OVER_BATCH_SIZE' using global batch size like: ``` with strategy.scope(): loss_obj = tf.keras.losses.CategoricalCrossentropy( reduction=tf.keras.losses.Reduction.NONE) .... loss = tf.reduce_sum(loss_obj(labels, predictions)) * (1. / global_batch_size) ``` Please see the [custom training guide]( https://www.tensorflow.org/tutorials/distribute/custom_training) for more details on this. autononesumsum_over_batch_sizec^URURURUR4$N)AUTONONESUMSUM_OVER_BATCH_SIZE)clss Y/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/utils/losses_utils.pyallReductionV2.allQs##((CGGS-D-DEEcjXR5;a [SUSUR5S35eg)NzInvalid Reduction Key: z. Expected keys are "")r ValueError)rkeys rvalidateReductionV2.validateUs9 ggi )#.CCGGI;aP  rN) __name__ __module__ __qualname____firstlineno____doc__rrrr classmethodrr__static_attributes__r rrr r sG,\ D D C/FFrr c^^[R"U=(d S5 [R"T5(d[R "T5m[R"T5(d[R "T5mTR nURnTR nURnUbUbXW- nXS-:Xa<URSRS5(a[R"TS/5mOCXS- :Xa;URSRS5(a[R"TS/5mTT4sSSS5 $[R"T5[R"T5- nUb#URSRS5(a8[R"[R"US-U5U4SjU4Sj5mUb#URSRS5(a8[R"[R"US- U5U4SjU4Sj5mTT4sSSS5 $!,(df  g=f) aSqueeze last dim if ranks differ from expected by exactly 1. In the common case where we expect shapes to match, `expected_rank_diff` defaults to 0, and we squeeze the last dimension of the larger rank if they differ by 1. But, for example, if `labels` contains class IDs and `predictions` contains 1 probability per class, we expect `predictions` to have 1 more dimension than `labels`, so `expected_rank_diff` would be 1. In this case, we'd squeeze `labels` if `rank(predictions) - rank(labels) == 0`, and `predictions` if `rank(predictions) - rank(labels) == 2`. This will use static shape if available. Otherwise, it will add graph operations, which could result in a performance hit. Args: labels: Label values, a `Tensor` whose dimensions match `predictions`. predictions: Predicted values, a `Tensor` of arbitrary dimensions. expected_rank_diff: Expected result of `rank(predictions) - rank(labels)`. name: Name of the op. Returns: Tuple of `labels` and `predictions`, possibly with last dim squeezed. remove_squeezable_dimensionsNc4>[R"TS/5$Nr+tfsqueeze predictionssr.remove_squeezable_dimensions..s ;5rc>T$rr r1srr3r4s rc4>[R"TS/5$r-r.labelssrr3r4s 6B40rc>T$rr r7srr3r4sr)r name_scoperis_tensor_or_extension_typer/convert_to_tensorshapendimsdimsis_compatible_withr0rankcondequal) r8r2expected_rank_diffnamepredictions_shapepredictions_rank labels_shape labels_rank rank_diffs `` rr)r)]s6   DB$B C33K@@..{;K33F;;))&1F'--,22|| "((  #*:*F(6I227H7M7M8  #8$!jjrd; 1449J9J:  #:$FRD1;&) D C.GGK(2776?:  $  " "2 & 9 9! < <''+a/;5#K     b ! 4 4Q 7 7WW+a/;0F {"Q D C CsD'I C,I  Ic^^^^ ^ ^^^TRnURnTbTRnURnUb$Ub!XF- S:wd USS:Xa[TT5ummO[R"T5[R"T5- mUU4Sjm[R "S[R"T5S5m U UUU4Sjn[R "[R "ST5UT5ummTcTT4$TRnURn U S:XaTTT4$UbIU bFX- S:Xa[R"TS/5mO XI- S:Xa[R"TS/5mTTT4$[R"T5n U [R"T5- mU4SjmUU4Sjm U UU4Sjn [R "[R "U S5U4S jU 5mTTT4$) aSqueeze or expand last dimension if needed. 1. Squeezes last dim of `y_pred` or `y_true` if their rank differs by 1 (using `remove_squeezable_dimensions`). 2. Squeezes or expands last dim of `sample_weight` if its rank differs by 1 from the new rank of `y_pred`. If `sample_weight` is scalar, it is kept scalar. This will use static shape if available. Otherwise, it will add graph operations, which could result in a performance hit. Args: y_pred: Predicted values, a `Tensor` of arbitrary dimensions. y_true: Optional label `Tensor` whose dimensions match `y_pred`. sample_weight: Optional weight scalar or `Tensor` whose dimensions match `y_pred`. Returns: Tuple of `y_pred`, `y_true` and `sample_weight`. Each of them possibly has the last dimension squeezed, `sample_weight` could be extended by one dimension. If `sample_weight` is None, (y_pred, y_true) is returned. r*r+c>[TT5$r)r)y_predy_truesrr3.squeeze_or_expand_dimensions..s #?#Orc>>[R"TTUU4Sj5$)Nc >TT4$rr rMsrr3@squeeze_or_expand_dimensions....s ff5Er)r/rB) is_last_dim_1 squeeze_dimsrNrOsrr3rPs|-E*rrc4>[R"TS/5$r-r. sample_weightsrr3rPsBJJ}rd$Crcr>U4Sjn[R"[R"TS5UU4Sj5$)Nc4>[R"TS/5$r-)r/ expand_dimsrWsrr3Msqueeze_or_expand_dimensions.._maybe_expand_weights..s t!Drr+c>T$rr rWsrr3r\s]rr/rBrC)expand_weightsrJrXs r_maybe_expand_weights;squeeze_or_expand_dimensions.._maybe_expand_weightss,Dww HHY #^5J  rc^>[R"[R"TS5TT5$)Nr*r^)r`maybe_squeeze_weightsrJsr_maybe_adjust_weights;squeeze_or_expand_dimensions.._maybe_adjust_weightss(ww HHY "$9;P  rc>T$rr rWsrr3rPs r) r=r>r)r/rArCrBr0r[)rNrOrX y_pred_shape y_pred_rank y_true_shape y_true_rankmaybe_squeeze_dims weights_shape weights_rankweights_rank_tensorrdr`rTrcrJrUs``` @@@@@rsqueeze_or_expand_dimensionsros0<  % *JJ}rd;M  '1 ,NN=2$?Mv},,''-0#bggfo5IC  GG $a(M 6= ((rcj[R"U5n[RRX!SS9$)aComputes a safe mean of the losses. Args: losses: `Tensor` whose elements contain individual loss measurements. num_present: The number of measurable elements in `losses`. Returns: A scalar representing the mean of `losses`. If `num_present` is zero, then zero is returned. valuerE)r/ reduce_summath divide_no_nan)losses num_present total_losss r _safe_meanrys,v&J 77 w GGrc[R"S5n[R"[R"XS9UR S9sSSS5 $!,(df  g=f)z3Computes the number of elements in `losses` tensor. num_elementsrr)dtypeN)rr:r/castsizer|)rvscopes r _num_elementsr s9   N +uwwrwwv2&,,G , + +s 1A A cU[R:XaUnU$[R"U5nU[R:Xa[ U[ U55nU$)z2Reduces the individual weighted loss measurements.)r rr/rsrryr)weighted_losses reductionlosss rreduce_weighted_lossrsRK$$$ K}}_-  77 7dM/$BCD Krz/keras.__internal__.losses.compute_weighted_lossc[RU5 U[R:Xa[RnUcSn[R "U=(d S5 U[ RRR5l [U[R[ R45(d[ R"U5n[U[R[ R45(d[ R"U5nUR R"(d&UR n[ R$"US5nSnOSn[ R$"XR 5n['USU5unnn[ R("X5n[+Xr5nU(a[ R$"UW5nUsSSS5 $!,(df  g=f)alComputes the weighted loss. Args: losses: `Tensor` of shape `[batch_size, d1, ... dN]`. sample_weight: Optional `Tensor` whose rank is either 0, or the same rank as `losses`, or be broadcastable to `losses`. reduction: (Optional) Type of `tf.keras.losses.Reduction` to apply to loss. Default value is `SUM_OVER_BATCH_SIZE`. name: Optional name for the op. Raises: ValueError: If the shape of `sample_weight` is not compatible with `losses`. Returns: Weighted loss `Tensor` of the same type as `losses`. If `reduction` is `NONE`, this has the same shape as `losses`; otherwise, it is scalar. N? weighted_lossfloat32TF)r rrrrr:r/compatrget_default_graph_last_loss_reduction isinstancer KerasTensor RaggedTensorr<r| is_floatingr}romultiplyr) rvrXrrE input_dtype input_casted_rrs rcompute_weighted_lossr sd2#K$$$33    D3O 4AJ &&(=&<#;#;R__"MNN))&1F L44booF  00?M||'' ,,KWWVY/FL L ||<  )} E   ++f<$O? 774-DI 5 4 4s E,G G"cr[RR5RnUS:aUSU- -nU$)zBScales and returns the given loss value by the number of replicas.r*r)r/ distribute get_strategynum_replicas_in_sync) loss_value num_replicass rscale_loss_for_distributionrhs7==--/DDLacL(( rcSnUHnURR(aJUb$URRUR:a URnOURU1SS1:XaSnURR(dMUs $ U(a&UVs/sHn[R "X!5PM nnU$s snf)aRCast a list of losses to a common dtype. If any loss is floating-point, they will all be casted to the most-precise floating-point loss. Otherwise the losses are not casted. We also skip casting losses if there are any complex losses. Args: losses: A list of losses. Returns: `losses`, but they have been casted to a common dtype. Nbfloat16float16r)r|rr~ is_complexr/r})rv highest_floatrs rcast_losses_to_common_dtyperpsM :: ! !$ -:L:L(L $ **m,Y0GG ) ::  ;AB64"''$.6B MCs B?c[USS5$)z"Returns TF-Keras mask from tensor. _keras_maskN)getattr)y_ps rget_maskrs 3 t ,,rcUbW[R"X R5nUb2[R"XR5n[X!S9up#nX-nU$UnU$)z2Applies any mask on predictions to sample weights.rW)r/r}r|ro)rswmaskrs r apply_maskrsY wwtYY' >ZZ(B6tNKDR JB IB IrcLUb[R"X R5nU[R[R 4;aR[R"[R "U5UR5n[R"U5nX$U- -n[XU5$)z;Redistribute sample weights considering only valid entries.) r/r}r|r rrr~rsr)rvrrrtotalvalids rapply_valid_maskrsx wwt\\* ));+J+JK KGGBGGDM6<<8EMM$'E EM !D f$ ''r)rN)NN)r%tensorflow.compat.v2rv2r/ tf_keras.srcrtf_keras.src.enginertf_keras.src.utilsr tensorflow.python.util.tf_exportrr r)roryrrrrrrrrrr rrrs +!! ,':&2.==/=B59C#LX)v HH +>> ?BG-- DHDN:- (r