AVh dZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZddlmZddlmZedgGddZdZd5dZdZedgej8ddej:j<ej>fdZ edgej8ddej:j<ej>fdZ!edgej8edd d!dddej:j<ej>dfd"Z"ed#gej8ddej:j<ej>fd$Z#ed%gej8dddej:j<ej>fd&Z$ed'gej8dd(dej:j<ej>fd)Z%ed*gej8ddej:j<fd+Z&ed,gej8ddej:j<ej>fd-Z'ed.gej8dddej:j<ej>fd/Z(ed0gej8dddej:j<ej>fd1Z) d6d2Z*ed3gej8ddej:j<ej>fd4Z+y)7z=Implementation of Loss operations for use in neural networks.)context)dtypes)ops) array_ops)cond)confusion_matrix)control_flow_ops)math_ops)nn)nn_ops)weights_broadcast_ops)util)dispatch)deprecated_args)deprecated_argument_lookup) tf_exportzlosses.Reduction)v1cHeZdZdZdZdZdZdZdZeZ e dZ e dZ y ) ReductionaTypes of loss reduction. Contains the following values: * `NONE`: Un-reduced weighted losses with the same shape as input. * `SUM`: Scalar sum of weighted losses. * `MEAN`: Scalar `SUM` divided by sum of weights. DEPRECATED. * `SUM_OVER_BATCH_SIZE`: Scalar `SUM` divided by number of elements in losses. * `SUM_OVER_NONZERO_WEIGHTS`: Scalar `SUM` divided by number of non-zero weights. DEPRECATED. * `SUM_BY_NONZERO_WEIGHTS`: Same as `SUM_OVER_NONZERO_WEIGHTS`. DEPRECATED. none weighted_sumweighted_sum_over_batch_size weighted_meanweighted_sum_by_nonzero_weightsc|j|j|j|j|j|j fSN)NONESUMMEANSUM_OVER_BATCH_SIZESUM_OVER_NONZERO_WEIGHTSSUM_BY_NONZERO_WEIGHTS)clss X/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/losses/losses_impl.pyallz Reduction.all9s>     $$ ""  $$ch||jvr td|d|jdy)NzInvalid Reduction Key z. Key should be one of .)r% ValueError)r#keys r$validatezReduction.validateCs> #'') /u4K'')A' ((r&N) __name__ __module__ __qualname____doc__rrr rr"r! classmethodr%r+r&r$rr#sP  $#6 $<3$$((r&rc\tj|}tj||dS)a,Computes 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. valuename)r reduce_sum div_no_nan)losses num_present total_losss r$ _safe_meanr;Js)""6**   Z7 CCr&c t|tr|dk7s=tjr4|j dk(r!t j |ds t|Stjdd||f5}t j|tj}tjt j |dtj|tj |}t#j$||}|rIt j&|t j(dtj*|d|cdddSt j&|| cdddS#1swYyxYw) aComputes the number of elements in the loss function induced by `weights`. A given weights tensor induces different numbers of usable elements in the `losses` tensor. The `weights` tensor is broadcast across `losses` for all possible dimensions. For example, if `losses` is a tensor of dimension `[4, 5, 6, 3]` and `weights` is a tensor of shape `[4, 5]`, then `weights` is, in effect, tiled to match the shape of `losses`. Following this effective tile, the total number of present elements is the number of non-zero weights. Args: losses: `Tensor` of shape `[batch_size, d1, ... dN]`. weights: `Tensor` of shape `[]`, `[batch_size]` or `[batch_size, d1, ... dK]`, where K < N. per_batch: Whether to return the number of elements per batch or as a sum total. Returns: The number of present (non-zero) elements in the losses tensor. If `per_batch` is `True`, the value is returned as a tensor of size `[batch_size]`. Otherwise, a single scalar tensor is returned. grNr9dtypeT)axiskeepdimsr5r4) isinstancefloatrexecuting_eagerly_rankr equal _num_elementsr name_scopecastrfloat32rwhere zeros_like ones_liker broadcast_weightsr6rangerank)r8weights per_batchscopepresents r$ _num_presentrUYs,'5!gn  "w}}!';~~gs+    ~~dMFG+<= 4mmG6>>:Goow$W%G$&G$55gvFG  ~~a!89  4 4   wU 3 4 4 4s7CE/E//E8ctjdd|g5}tjt j |||j cdddS#1swYyxYw)z3Computes the number of elements in `losses` tensor.N num_elements)valuesr4r=)rrHr rIrsizer>)r8rSs r$rGrGsL ~~dNF8<Q ==U;6<< PQQQs 6AA#zlosses.compute_weighted_loss?Nctj|tj|d||f5|tj_d}t j|||||cdddStjtj||f5|||||cdddcdddS#1swYnxYw dddy#1swYyxYw)aComputes the weighted loss. Args: losses: `Tensor` of shape `[batch_size, d1, ... dN]`. weights: Optional `Tensor` whose rank is either 0, or the same rank as `losses`, and must be broadcastable to `losses` (i.e., all dimensions must be either `1`, or the same as the corresponding `losses` dimension). scope: the scope for the operations performed in computing the loss. loss_collection: the loss will be added to these collections. reduction: Type of reduction to apply to loss. 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. Raises: ValueError: If `weights` is `None` or the shape is not compatible with `losses`, or if the number of dimensions (rank) of either `losses` or `weights` is missing. Note: When calculating the gradient of a weighted loss contributions from both `losses` and `weights` are considered. If your `weights` depend on some model parameters but you do not want this to affect the loss gradient, you need to apply `tf.stop_gradient` to `weights` before passing them to `compute_weighted_loss`. @compatibility(eager) The `loss_collection` argument is ignored when executing eagerly. Consider holding on to the return value or collecting losses via a `tf.keras.Model`. @end_compatibility weighted_lossctj|}|j}tj|t j }tj|t j }tj||}|tjk(r|}ntj|}|tjk(r6t|tjtj||z}ne|tjk(s|tj k(rt|t#||}n(|tj$k(rt|t'|}tj||}t)j*|||S)Nr=)rconvert_to_tensorr>r rIrrJmultiplyrrr6rr;rrMr"r!rUr rGradd_loss)r8rQloss_collection reduction input_dtypeweighted_losseslosss r$ compute_lossz+compute_weighted_loss..compute_losss $$V,fLLk}}V6>>:f gV^^-- 6>>BK ]]6 8F55f6F6F6HI \\(++K@ AF 9 F FFFs B0C//C8zlosses.cosine_distancez#dim is deprecated, use axis insteaddimc>td|d|}| td| td| tdtj|d|||f5}t j |t j}t j |t j}|jj|jt j||}d t j||fd z } t| |||| cdddS#1swYyxYw) aAdds a cosine-distance loss to the training procedure. Note that the function assumes that `predictions` and `labels` are already unit-normalized. Args: labels: `Tensor` whose shape matches 'predictions' predictions: An arbitrary matrix. axis: The dimension along which the cosine distance is computed. weights: Optional `Tensor` whose rank is either 0, or the same rank as `labels`, and must be broadcastable to `labels` (i.e., all dimensions must be either `1`, or the same as the corresponding `losses` dimension). scope: The scope for the operations performed in computing the loss. loss_collection: collection to which this loss will be added. reduction: Type of reduction to apply to loss. dim: The old (deprecated) name for `axis`. Returns: Weighted loss float `Tensor`. If `reduction` is `NONE`, this has the same shape as `labels`; otherwise, it is scalar. Raises: ValueError: If `predictions` shape doesn't match `labels` shape, or `axis`, `labels`, `predictions` or `weights` is `None`. @compatibility(eager) The `loss_collection` argument is ignored when executing eagerly. Consider holding on to the return value or collecting losses via a `tf.keras.Model`. @end_compatibility r@ryNz!You must specify argument `axis`.rnrocosine_distance_lossr=r?Tr@rArq) rr)rrHr rIrrJrrrsr_r6rl) rwrxr@rQrSrarbry radial_diffsr8s r$cosine_distancer~s L $FD% =$ \ 8 99 ^ : ;; ? @@ ~~e3"FG46 F9>-- 6>>BK ]]6 8F55f6F6F6HI$$[&9L $$\$O OF 9 F F F Fs B9DDzlosses.hinge_lossc z| td| tdtj|d|||f5}tj|t j }tj|t j }|jj|jtj|}tjd|z|}tjtj|tj||}t|||||cdddS#1swYyxYw)a^Adds a hinge loss to the training procedure. Args: labels: The ground truth output tensor. Its shape should match the shape of logits. The values of the tensor are expected to be 0.0 or 1.0. Internally the {0,1} labels are converted to {-1,1} when calculating the hinge loss. logits: The logits, a float tensor. Note that logits are assumed to be unbounded and 0-centered. A value > 0 (resp. < 0) is considered a positive (resp. negative) binary prediction. weights: Optional `Tensor` whose rank is either 0, or the same rank as `labels`, and must be broadcastable to `labels` (i.e., all dimensions must be either `1`, or the same as the corresponding `losses` dimension). scope: The scope for the operations performed in computing the loss. loss_collection: collection to which the loss will be added. reduction: Type of reduction to apply to loss. Returns: Weighted loss float `Tensor`. If `reduction` is `NONE`, this has the same shape as `labels`; otherwise, it is scalar. Raises: ValueError: If the shapes of `logits` and `labels` don't match or if `labels` or `logits` is None. @compatibility(eager) The `loss_collection` argument is ignored when executing eagerly. Consider holding on to the return value or collecting losses via a `tf.keras.Model`. @end_compatibility Nrn#Argument `logits` must not be None. hinge_lossr=rq)r)rrHr rIrrJrrrsrrMrur relur_rl)rwlogitsrQrSrarball_onesr8s r$rrGsD ^ : ;; ^ : ;; ~~e\FFG+DE F ]]6 8F ]]6 8F 001A1A1CD""6*H   q6z8 4F [[(H$5$5ff$EFHF 9 F F F Fs C2D11D:zlosses.huber_lossc 4| td| tdtj|d|||f5}tj|t j }tj|t j }|jj|jtj||}tj|}tj||} tj|| } tjtjtjd| jtj| | tj|| } t!| ||||cdddS#1swYyxYw)aAdds a [Huber Loss](https://en.wikipedia.org/wiki/Huber_loss) term to the training procedure. For each value x in `error=labels-predictions`, the following is calculated: ``` 0.5 * x^2 if |x| <= d 0.5 * d^2 + d * (|x| - d) if |x| > d ``` where d is `delta`. `weights` acts as a coefficient for the loss. If a scalar is provided, then the loss is simply scaled by the given value. If `weights` is a tensor of size `[batch_size]`, then the total loss for each sample of the batch is rescaled by the corresponding element in the `weights` vector. If the shape of `weights` matches the shape of `predictions`, then the loss of each measurable element of `predictions` is scaled by the corresponding value of `weights`. Args: labels: The ground truth output tensor, same dimensions as 'predictions'. predictions: The predicted outputs. weights: Optional `Tensor` whose rank is either 0, or the same rank as `labels`, and must be broadcastable to `labels` (i.e., all dimensions must be either `1`, or the same as the corresponding `losses` dimension). delta: `float`, the point where the huber loss function changes from a quadratic to linear. scope: The scope for the operations performed in computing the loss. loss_collection: collection to which the loss will be added. reduction: Type of reduction to apply to loss. Returns: Weighted loss float `Tensor`. If `reduction` is `NONE`, this has the same shape as `labels`; otherwise, it is scalar. Raises: ValueError: If the shape of `predictions` doesn't match that of `labels` or if the shape of `weights` is invalid. Also if `labels` or `predictions` is None. @compatibility(eager) The `loss_collection` argument is ignored when executing eagerly. Consider holding on to the return value or collecting losses via a `tf.keras.Model`. @end_compatibility Nrnro huber_lossr=?rq)r)rrHr rIrrJrrrsrurtminimumaddr_r^r>rl) rwrxrQdeltarSrarberror abs_error quadraticlinearr8s r$rrzsTd ^ : ;; ? @@ ~~e\"FG46F9>-- 6>>BK ]]6 8F55f6F6F6HI   k6 2E U#I  E2I   y) 4F \\  ! !#Y__ =   i 3 5 %( *F !9 F'FFFs EFFzlosses.log_lossgHz>c d| td| tdtj|d|||f5}tj|t j }tj|t j }|jj|jtj|tj||z tjd|z tjd|z |zz }t|||||cdddS#1swYyxYw)a~Adds a Log Loss term to the training procedure. `weights` acts as a coefficient for the loss. If a scalar is provided, then the loss is simply scaled by the given value. If `weights` is a tensor of size `[batch_size]`, then the total loss for each sample of the batch is rescaled by the corresponding element in the `weights` vector. If the shape of `weights` matches the shape of `predictions`, then the loss of each measurable element of `predictions` is scaled by the corresponding value of `weights`. Args: labels: The ground truth output tensor, same dimensions as 'predictions'. predictions: The predicted outputs. weights: Optional `Tensor` whose rank is either 0, or the same rank as `labels`, and must be broadcastable to `labels` (i.e., all dimensions must be either `1`, or the same as the corresponding `losses` dimension). epsilon: A small increment to add to avoid taking a log of zero. scope: The scope for the operations performed in computing the loss. loss_collection: collection to which the loss will be added. reduction: Type of reduction to apply to loss. Returns: Weighted loss float `Tensor`. If `reduction` is `NONE`, this has the same shape as `labels`; otherwise, it is scalar. Raises: ValueError: If the shape of `predictions` doesn't match that of `labels` or if the shape of `weights` is invalid. Also if `labels` or `predictions` is None. @compatibility(eager) The `loss_collection` argument is ignored when executing eagerly. Consider holding on to the return value or collecting losses via a `tf.keras.Model`. @end_compatibility Nrnrolog_lossr=r?rq) r)rrHr rIrrJrrrsr_logrl)rwrxrQepsilonrSrarbr8s r$rrsP ^ : ;; ? @@ ~~eZ"FG46 F9>-- 6>>BK ]]6 8F55f6F6F6HI [7*+--/7/@/@ Z(,,q;'@A0CCF !9 F F F Fs C'D&&D/z"losses.mean_pairwise_squared_errorc*| td| tdtj|d|||f5}tj|t j }tj|t j }d}tj|||||cdddStjtj||f5|||||cdddcdddS#1swYnxYw dddy#1swYyxYw)aAdds a pairwise-errors-squared loss to the training procedure. Unlike `mean_squared_error`, which is a measure of the differences between corresponding elements of `predictions` and `labels`, `mean_pairwise_squared_error` is a measure of the differences between pairs of corresponding elements of `predictions` and `labels`. For example, if `labels`=[a, b, c] and `predictions`=[x, y, z], there are three pairs of differences are summed to compute the loss: loss = [ ((a-b) - (x-y)).^2 + ((a-c) - (x-z)).^2 + ((b-c) - (y-z)).^2 ] / 3 Note that since the inputs are of shape `[batch_size, d0, ... dN]`, the corresponding pairs are computed within each batch sample but not across samples within a batch. For example, if `predictions` represents a batch of 16 grayscale images of dimension [batch_size, 100, 200], then the set of pairs is drawn from each image, but not across images. `weights` acts as a coefficient for the loss. If a scalar is provided, then the loss is simply scaled by the given value. If `weights` is a tensor of size `[batch_size]`, then the total loss for each sample of the batch is rescaled by the corresponding element in the `weights` vector. Args: labels: The ground truth output tensor, whose shape must match the shape of `predictions`. predictions: The predicted outputs, a tensor of size `[batch_size, d0, .. dN]` where N+1 is the total number of dimensions in `predictions`. weights: Coefficients for the loss a scalar, a tensor of shape `[batch_size]` or a tensor whose shape matches `predictions`. scope: The scope for the operations performed in computing the loss. loss_collection: collection to which the loss will be added. Returns: A scalar `Tensor` that returns the weighted loss. Raises: ValueError: If the shape of `predictions` doesn't match that of `labels` or if the shape of `weights` is invalid. Also if `labels` or `predictions` is None. @compatibility(eager) The `loss_collection` argument is ignored when executing eagerly. Consider holding on to the return value or collecting losses via a `tf.keras.Model`. @end_compatibility Nrnromean_pairwise_squared_errorr=c tj|tj}|j j |j tj ||}tjdtj|}tjtj||d}t||d}dtj|tj|dz dd z}tj||d} dtjtj| tjtj||dz dd z} tj|| z |} tj| } tj tj|dkD| tj"| d } t%j&| || S) Nr=r?Tr|)rRg@rr3r4)r rIrrJrrrsrurOrrPr6squarerUr7maximumr_rKrLrr`)rwrxrQradiffsr@sum_squares_diff_per_batchnum_present_per_batchterm1sum_diffterm2rdre mean_losss r$rfz1mean_pairwise_squared_error..compute_loss=sMM+V^^Dk778H8H8JK V4e ^^Ay~~e4 5d#+#6#6 //% td$< *5'TJH'' $   014a 8e $$UEhH'' //( #    5 5 9;<= ? e!))%%-Ao   1d//   3 4q 8    t $ i  mmI/ r&) r)rrHr rIrrJr rirjr rk)rwrxrQrSrarfs r$rrs f ^ : ;; ? @@ ~~e:"FG462K9>mmG6>>:G ]]6 8F"P113? &+w H]2K2K`  # # 5 5gv F H JKFK/JKKa2K2K`KKKa2K2K2Ks*A,D +*D  C3 D 3C< 8D  Dzlosses.mean_squared_errorc| td| tdtj|d|||f5}tj|t j }tj|t j }|jj|jtj||}t|||||cdddS#1swYyxYw)aAdds a Sum-of-Squares loss to the training procedure. `weights` acts as a coefficient for the loss. If a scalar is provided, then the loss is simply scaled by the given value. If `weights` is a tensor of size `[batch_size]`, then the total loss for each sample of the batch is rescaled by the corresponding element in the `weights` vector. If the shape of `weights` matches the shape of `predictions`, then the loss of each measurable element of `predictions` is scaled by the corresponding value of `weights`. Args: labels: The ground truth output tensor, same dimensions as 'predictions'. predictions: The predicted outputs. weights: Optional `Tensor` whose rank is either 0, or the same rank as `labels`, and must be broadcastable to `labels` (i.e., all dimensions must be either `1`, or the same as the corresponding `losses` dimension). scope: The scope for the operations performed in computing the loss. loss_collection: collection to which the loss will be added. reduction: Type of reduction to apply to loss. Returns: Weighted loss float `Tensor`. If `reduction` is `NONE`, this has the same shape as `labels`; otherwise, it is scalar. Raises: ValueError: If the shape of `predictions` doesn't match that of `labels` or if the shape of `weights` is invalid. Also if `labels` or `predictions` is None. @compatibility(TF2) `tf.compat.v1.losses.mean_squared_error` is mostly compatible with eager execution and `tf.function`. But, the `loss_collection` argument is ignored when executing eagerly and no loss will be written to the loss collections. You will need to either hold on to the return value manually or rely on `tf.keras.Model` loss tracking. To switch to native TF2 style, instantiate the `tf.keras.losses.MeanSquaredError` class and call the object instead. #### Structural Mapping to Native TF2 Before: ```python loss = tf.compat.v1.losses.mean_squared_error( labels=labels, predictions=predictions, weights=weights, reduction=reduction) ``` After: ```python loss_fn = tf.keras.losses.MeanSquaredError( reduction=reduction) loss = loss_fn( y_true=labels, y_pred=predictions, sample_weight=weights) ``` #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :-------------------- | :--------------- | :------------------------- | | `labels` | `y_true` | In `__call__()` method | | `predictions` | `y_pred` | In `__call__()` method | | `weights` | `sample_weight` | In `__call__()` method. | : : : The shape requirements for `sample_weight` is different from : : : : `weights`. Please check the [argument definition][api_docs] for : : : : details. : | `scope` | Not supported | - | | `loss_collection` | Not supported | Losses should be tracked | : : : explicitly or with Keras APIs, for example, [add_loss][add_loss], : : : : instead of via collections : | `reduction` | `reduction` | In constructor. Value of | : : : `tf.compat.v1.losses.Reduction.SUM_OVER_BATCH_SIZE`, : : : : `tf.compat.v1.losses.Reduction.SUM`, : : : : `tf.compat.v1.losses.Reduction.NONE` in : : : : `tf.compat.v1.losses.softmax_cross_entropy` correspond to : : : : `tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE`, : : : : `tf.keras.losses.Reduction.SUM`, : : : : `tf.keras.losses.Reduction.NONE`, respectively. If you : : : : used other value for `reduction`, including the default value : : : : `tf.compat.v1.losses.Reduction.SUM_BY_NONZERO_WEIGHTS`, there is : : : : no directly corresponding value. Please modify the loss : : : : implementation manually. : [add_loss]:https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer#add_loss [api_docs]:https://www.tensorflow.org/api_docs/python/tf/keras/losses/MeanSquaredError#__call__ #### Before & After Usage Example Before: >>> y_true = [1, 2, 3] >>> y_pred = [1, 3, 5] >>> weights = [0, 1, 0.25] >>> # samples with zero-weight are excluded from calculation when `reduction` >>> # argument is set to default value `Reduction.SUM_BY_NONZERO_WEIGHTS` >>> tf.compat.v1.losses.mean_squared_error( ... labels=y_true, ... predictions=y_pred, ... weights=weights).numpy() 1.0 >>> tf.compat.v1.losses.mean_squared_error( ... labels=y_true, ... predictions=y_pred, ... weights=weights, ... reduction=tf.compat.v1.losses.Reduction.SUM_OVER_BATCH_SIZE).numpy() 0.66667 After: >>> y_true = [[1.0], [2.0], [3.0]] >>> y_pred = [[1.0], [3.0], [5.0]] >>> weights = [1, 1, 0.25] >>> mse = tf.keras.losses.MeanSquaredError( ... reduction=tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE) >>> mse(y_true=y_true, y_pred=y_pred, sample_weight=weights).numpy() 0.66667 @end_compatibility Nrnromean_squared_errorr=rq) r)rrHr rIrrJrrrssquared_differencerlrvs r$rrmsP ^ : ;; ? @@ ~~e1"FG46F9>-- 6>>BK ]]6 8F55f6F6F6HI  ( (f =F 9 F FFF BCC%zlosses.sigmoid_cross_entropyc| td| tdtj|d|||f5}tj|}t j ||j }|jj|j|dkDr|d|z zd|zz}tj||d }t||||| cdddS#1swYyxYw) aCreates a cross-entropy loss using tf.nn.sigmoid_cross_entropy_with_logits. `weights` acts as a coefficient for the loss. If a scalar is provided, then the loss is simply scaled by the given value. If `weights` is a tensor of shape `[batch_size]`, then the loss weights apply to each corresponding sample. If `label_smoothing` is nonzero, smooth the labels towards 1/2: new_multiclass_labels = multiclass_labels * (1 - label_smoothing) + 0.5 * label_smoothing Args: multi_class_labels: `[batch_size, num_classes]` target integer labels in `{0, 1}`. logits: Float `[batch_size, num_classes]` logits outputs of the network. weights: Optional `Tensor` whose rank is either 0, or the same rank as `multi_class_labels`, and must be broadcastable to `multi_class_labels` (i.e., all dimensions must be either `1`, or the same as the corresponding `losses` dimension). label_smoothing: If greater than `0` then smooth the labels. scope: The scope for the operations performed in computing the loss. loss_collection: collection to which the loss will be added. reduction: Type of reduction to apply to loss. Returns: Weighted loss `Tensor` of the same type as `logits`. If `reduction` is `NONE`, this has the same shape as `logits`; otherwise, it is scalar. Raises: ValueError: If the shape of `logits` doesn't match that of `multi_class_labels` or if the shape of `weights` is invalid, or if `weights` is None. Also if `multi_class_labels` or `logits` is None. @compatibility(eager) The `loss_collection` argument is ignored when executing eagerly. Consider holding on to the return value or collecting losses via a `tf.keras.Model`. @end_compatibility Nz/Argument `multi_class_labels` must not be None.rsigmoid_cross_entropy_lossrr?rxentropyrwrr5rq) r)rrHr^r rIr>rrrsr !sigmoid_cross_entropy_with_logitsrl)multi_class_labelsrrQlabel_smoothingrSrarbr8s r$sigmoid_cross_entropyrsZ F GG ^ : ;; ~~e917;=F@E  " "6 *F!'96<<H 001C1M1M1OP.!o2EF/12 1 19K9?7ACF !9 FFFFrzlosses.softmax_cross_entropycr| td| tdtj|d|||f5}tj|}t j ||j }|jj|j|dkDrHt j tj|d|j }d|z }||z } ||z| z}tj|d }tj||d } t| |||| cdddS#1swYyxYw) adCreates a cross-entropy loss using tf.nn.softmax_cross_entropy_with_logits_v2. `weights` acts as a coefficient for the loss. If a scalar is provided, then the loss is simply scaled by the given value. If `weights` is a tensor of shape `[batch_size]`, then the loss weights apply to each corresponding sample. If `label_smoothing` is nonzero, smooth the labels towards 1/num_classes: new_onehot_labels = onehot_labels * (1 - label_smoothing) + label_smoothing / num_classes Note that `onehot_labels` and `logits` must have the same shape, e.g. `[batch_size, num_classes]`. The shape of `weights` must be broadcastable to loss, whose shape is decided by the shape of `logits`. In case the shape of `logits` is `[batch_size, num_classes]`, loss is a `Tensor` of shape `[batch_size]`. Args: onehot_labels: One-hot-encoded labels. logits: Logits outputs of the network. weights: Optional `Tensor` that is broadcastable to loss. label_smoothing: If greater than 0 then smooth the labels. scope: the scope for the operations performed in computing the loss. loss_collection: collection to which the loss will be added. reduction: Type of reduction to apply to loss. Returns: Weighted loss `Tensor` of the same type as `logits`. If `reduction` is `NONE`, this has shape `[batch_size]`; otherwise, it is scalar. Raises: ValueError: If the shape of `logits` doesn't match that of `onehot_labels` or if the shape of `weights` is invalid or if `weights` is None. Also if `onehot_labels` or `logits` is None. @compatibility(TF2) `tf.compat.v1.losses.softmax_cross_entropy` is mostly compatible with eager execution and `tf.function`. But, the `loss_collection` argument is ignored when executing eagerly and no loss will be written to the loss collections. You will need to either hold on to the return value manually or rely on `tf.keras.Model` loss tracking. To switch to native TF2 style, instantiate the `tf.keras.losses.CategoricalCrossentropy` class with `from_logits` set as `True` and call the object instead. #### Structural Mapping to Native TF2 Before: ```python loss = tf.compat.v1.losses.softmax_cross_entropy( onehot_labels=onehot_labels, logits=logits, weights=weights, label_smoothing=smoothing) ``` After: ```python loss_fn = tf.keras.losses.CategoricalCrossentropy( from_logits=True, label_smoothing=smoothing) loss = loss_fn( y_true=onehot_labels, y_pred=logits, sample_weight=weights) ``` #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :-------------------- | :--------------- | :------------------------- | | - | `from_logits` | Set `from_logits` as True | : : : to have identical behavior : | `onehot_labels` | `y_true` | In `__call__()` method | | `logits` | `y_pred` | In `__call__()` method | | `weights` | `sample_weight` | In `__call__()` method | | `label_smoothing` | `label_smoothing`| In constructor | | `scope` | Not supported | - | | `loss_collection` | Not supported | Losses should be tracked | : : : explicitly or with Keras : : : : APIs, for example, : : : : [add_loss][add_loss], : : : : instead of via collections : | `reduction` | `reduction` | In constructor. Value of | : : : `tf.compat.v1.losses.Reduction.SUM_OVER_BATCH_SIZE`, : : : : `tf.compat.v1.losses.Reduction.SUM`, : : : : `tf.compat.v1.losses.Reduction.NONE` in : : : : `tf.compat.v1.losses.softmax_cross_entropy` correspond to : : : : `tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE`, : : : : `tf.keras.losses.Reduction.SUM`, : : : : `tf.keras.losses.Reduction.NONE`, respectively. If you : : : : used other value for `reduction`, including the default value : : : : `tf.compat.v1.losses.Reduction.SUM_BY_NONZERO_WEIGHTS`, there is : : : : no directly corresponding value. Please modify the loss : : : : implementation manually. : [add_loss]:https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer#add_loss #### Before & After Usage Example Before: >>> y_true = [[0, 1, 0], [0, 0, 1]] >>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]] >>> weights = [0.3, 0.7] >>> smoothing = 0.2 >>> tf.compat.v1.losses.softmax_cross_entropy(y_true, y_pred, weights=weights, ... label_smoothing=smoothing).numpy() 0.57618 After: >>> cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True, ... label_smoothing=smoothing) >>> cce(y_true, y_pred, sample_weight=weights).numpy() 0.57618 @end_compatibility Nz*Argument `onehot_labels` must not be None.rsoftmax_cross_entropy_lossrrZlabels_stop_gradientr4rrrq)r)rrHr^r rIr>rrrsrshape stop_gradientr $softmax_cross_entropy_with_logits_v2rl) onehot_labelsrrQrrSrarb num_classessmooth_positivessmooth_negativesr8s r$softmax_cross_entropyrEs:H A BB ^ : ;; ~~e9}g68F;@  " "6 *FMM->M 001H1H1JKMM //- ( ,fllF !9 F%FFFs C.D--D6c4tj|||\}}tj|j j }j }|j }|(|&||z }|dk(rt jdg||fSt jt j|z }|#|dkDrO|jdjdr1tjtjd|fdfd||fS)aXInternal version of _remove_squeezable_dimensions which handles weights. Squeezes `predictions` and `labels` if their ranks differ from expected by exactly 1. Squeezes `weights` if its rank is 1 more than the new rank of `predictions` 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. weights: Optional weight `Tensor`. It will be squeezed if it's not scalar, and its rank is 1 more than the new rank of `labels`. expected_rank_diff: Expected result of `rank(predictions) - rank(labels)`. Returns: Tuple of `predictions`, `labels` and `weights`, possibly with the last dimension squeezed. expected_rank_diffr?rrc2tjdgS)Nr)rsqueezerQsr$z/_remove_squeezable_dimensions..s)##GbT2r&cSrr1rsr$rz/_remove_squeezable_dimensions..s'r&)rremove_squeezable_dimensionsrr^rrndimsrrrPdimsis_compatible_withrr rF)rwrxrQr labels_rank weights_shape weights_rank rank_diffs ` r$_remove_squeezable_dimensionsrs,)EE k.@B&+ ##G,G""$**K%%'M &&Ll&>,i a##GbT2 [' ))w')..*@@Iq]//3FFqI ..I & 2 g g %%r&z#losses.sparse_softmax_cross_entropyc | td| tdtj|d|||f5}t|||d\}}}t j ||d}t ||||| cdddS#1swYyxYw) awCross-entropy loss using `tf.nn.sparse_softmax_cross_entropy_with_logits`. `weights` acts as a coefficient for the loss. If a scalar is provided, then the loss is simply scaled by the given value. If `weights` is a tensor of shape `[batch_size]`, then the loss weights apply to each corresponding sample. Args: labels: `Tensor` of shape `[d_0, d_1, ..., d_{r-1}]` (where `r` is rank of `labels` and result) and dtype `int32` or `int64`. Each entry in `labels` must be an index in `[0, num_classes)`. Other values will raise an exception when this op is run on CPU, and return `NaN` for corresponding loss and gradient rows on GPU. logits: Unscaled log probabilities of shape `[d_0, d_1, ..., d_{r-1}, num_classes]` and dtype `float16`, `float32` or `float64`. weights: Coefficients for the loss. This must be scalar or broadcastable to `labels` (i.e. same rank and each dimension is either 1 or the same). scope: the scope for the operations performed in computing the loss. loss_collection: collection to which the loss will be added. reduction: Type of reduction to apply to loss. Returns: Weighted loss `Tensor` of the same type as `logits`. If `reduction` is `NONE`, this has the same shape as `labels`; otherwise, it is scalar. Raises: ValueError: If the shapes of `logits`, `labels`, and `weights` are incompatible, or if any of them are None. @compatibility(eager) The `loss_collection` argument is ignored when executing eagerly. Consider holding on to the return value or collecting losses via a `tf.keras.Model`. @end_compatibility Nrnr!sparse_softmax_cross_entropy_lossr?rrrrq)r)rrHrr (sparse_softmax_cross_entropy_with_logitsrl)rwrrQrSrarbr8s r$sparse_softmax_cross_entropyrsR ^ : ;; ^ : ;; ~~e@vw/1 F49<A7FFG  8 8@F>HJF !9 F F F Fs ;A::B)F)Nr),r/tensorflow.python.eagerrtensorflow.python.frameworkrrtensorflow.python.opsrrrr r r r r tensorflow.python.ops.lossesrtensorflow.python.utilr"tensorflow.python.util.deprecationrr tensorflow.python.util.tf_exportrrr;rUrGadd_dispatch_support GraphKeysLOSSESr"rlrpr~rrrrrrrrrr1r&r$rsD+.++&22*$(7-+>I6 !"##(#($#(L D'4TQ  -./ tS]]5I5I..JI0JIZ +,- !$DMM((..1F.1Fh '()