B )`0 @sdZddlmZddlmZddlmZddlmZddlmZddlm Z ddl m Z dd l m Z dd l m Z dd l mZdd l mZdd l mZddl mZddlmZddlmZddlmZddlmZddlmZedgdGdddeZddZdGddZddZedgdej d d!e j!j"ej#fd"d#Z$ed$gdej d d!e j!j"ej#fd%d&Z%ed'gdej ed!d(d)d!d d!e j!j"ej#d!fd*d+Z&ed,gdej d d!e j!j"ej#fd-d.Z'ed/gdej d d d!e j!j"ej#fd0d1Z(ed2gdej d d3d!e j!j"ej#fd4d5Z)ed6gdej d d!e j!j"fd7d8Z*ed9gdej d d!e j!j"ej#fd:d;Z+edZ,ed?gdej d dd!e j!j"ej#fd@dAZ-dHdBdCZ.edDgdej d d!e j!j"ej#fdEdFZ/d!S)Iz=Implementation of Loss operations for use in neural networks.)absolute_import)division)print_function)context)dtypes)ops) array_ops)confusion_matrix)control_flow_ops)math_ops)nn)nn_ops)weights_broadcast_ops)util)dispatch)deprecated_args)deprecated_argument_lookup) tf_exportzlosses.Reduction)Zv1c@s@eZdZdZdZdZdZdZdZeZ e ddZ e d d Z d S) 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. noneZ weighted_sumZweighted_sum_over_batch_sizeZ weighted_meanZweighted_sum_by_nonzero_weightscCs|j|j|j|j|j|jfS)N)NONESUMMEANSUM_OVER_BATCH_SIZESUM_OVER_NONZERO_WEIGHTSSUM_BY_NONZERO_WEIGHTS)clsrW/home/dcms/DCMS/lib/python3.7/site-packages/tensorflow/python/ops/losses/losses_impl.pyall<s z Reduction.allcCs||krtd|dS)NzInvalid Reduction Key %s.)r ValueError)rkeyrrrvalidateFs zReduction.validateN) __name__ __module__ __qualname____doc__rrrrrr classmethodrr"rrrrr&s  rcCst|}tj||ddS)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. value)name)r reduce_sum div_no_nan)losses num_presentZ total_lossrrr _safe_meanLs r.Fc Cst|tr|dks2tr:|dkr:t|ds:t|St dd||fr}tj |t j d}t t|dt |t |}t||}|rtj|tdt |d|dStj||d SQRXdS) 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. grNr-)dtypeT)axiskeepdimsr))r)) isinstancefloatrZexecuting_eagerlyZ_rankr equal _num_elementsr name_scopecastrfloat32rwhere zeros_like ones_likerZbroadcast_weightsr*rangerank)r,weights per_batchscopeZpresentrrr _num_present[s$    rBc Cs8tjdd|gd}tjtj||d|jdSQRXdS)z3Computes the number of elements in `losses` tensor.NZ num_elements)values)r))r/)rr7r r8rsizer/)r,rArrrr6sr6zlosses.compute_weighted_lossg?Nc Cs*t|t|d||f|t_tt||ft |}|j }t j |t jd}t j |t jd}t ||}|tjkr|}nnt |}|tjkrt|t t||}n>|tjks|tjkrt|t||}n|tjkrt|t|}t ||}t|||SQRXWdQRXdS)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 Z weighted_loss)r/N)rr"rr7Zget_default_graphZ_last_loss_reductioncontrol_dependenciesrassert_broadcastableconvert_to_tensorr/r r8rr9multiplyrr*rr.rr<rrrBrr6radd_loss)r,r?rAloss_collection reductionZ input_dtypeweighted_losseslossrrrcompute_weighted_losss0%            rNzlosses.absolute_differencec Cs|dkrtd|dkr tdt|d|||fX}tj|tjd}tj|tjd}||t t ||}t |||||dSQRXdS)aEAdds an Absolute Difference 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 shape `[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 this 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 or 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 Nzlabels must not be None.zpredictions must not be None.absolute_difference)r/)rK) r rr7r r8rr9 get_shapeassert_is_compatible_withabssubtractrN)labels predictionsr?rArJrKr,rrrrOs(rOzlosses.cosine_distancez#dim is deprecated, use axis insteaddimc Cstd|d|}|dkrtd|dkr.td|dkr>tdt|d|||fh}tj|tjd}tj|tjd}| |t ||}d tj ||fd d } t | ||||d SQRXdS) 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 r1rVNzYou must specify 'axis'.zlabels must not be None.zpredictions must not be None.Zcosine_distance_loss)r/r0T)r1r2)rK) rr rr7r r8rr9rPrQrHr*rN) rTrUr1r?rArJrKrVZ radial_diffsr,rrrcosine_distances & rWzlosses.hinge_lossc Cs|dkrtd|dkr tdt|d|||fz}tj|tjd}tj|tjd}||t |}t d||}t t |t||}t|||||dSQRXdS)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 Nzlabels must not be None.zlogits must not be None. hinge_loss)r/)rK)r rr7r r8rr9rPrQrr<rSr ZrelurHrN)rTlogitsr?rArJrKall_onesr,rrrrX?s" rXzlosses.huber_lossc Cs|dkrtd|dkr tdt|d|||f}tj|tjd}tj|tjd}||t ||}t |}t ||} t || } t t tjd| jdt | | t || } t| ||||dSQRXdS)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 Nzlabels must not be None.zpredictions must not be None. huber_loss)r/g?)rK)r rr7r r8rr9rPrQrSrRZminimumaddrHrGr/rN) rTrUr?deltarArJrKerrorZ abs_errorZ quadraticZlinearr,rrrr\rs(2     r\zlosses.log_lossgHz>c Cs|dkrtd|dkr tdt|d|||f|}tj|tjd}tj|tjd}||t |t || t d|t d||}t |||||dSQRXdS)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 Nzlabels must not be None.zpredictions must not be None.log_loss)r/r0)rK) r rr7r r8rr9rPrQrHlogrN)rTrUr?epsilonrArJrKr,rrrr`s(r`z"losses.mean_pairwise_squared_errorc Cs|dkrtd|dkr tdt|d|||fR}tj|tjd}tj|tjd}tt ||ftj|tjd}| | t ||}t dt|}tjt||dd}t||dd }d tj|t|dd d d } tj||dd} d tjt| tt||dd d d } t| | |} t| } tjt|d k| t| d d }t|||SQRXWdQRXdS)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 Nzlabels must not be None.zpredictions must not be None.mean_pairwise_squared_error)r/r0T)r1r2)r@g@rr()r))r rr7r r8rr9rErrFrPrQrSr=rr>r*ZsquarerBr+maximumrHr:r;rrI)rTrUr?rArJZdiffsr1Zsum_squares_diff_per_batchZnum_present_per_batchZterm1Zsum_diffZterm2rLrMZ mean_lossrrrrcsJ3       rczlosses.mean_squared_errorc Cs|dkrtd|dkr tdt|d|||fR}tj|tjd}tj|tjd}||t ||}t |||||dSQRXdS)a?Adds 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(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 Nzlabels must not be None.zpredictions must not be None.mean_squared_error)r/)rK) r rr7r r8rr9rPrQZsquared_differencerN)rTrUr?rArJrKr,rrrreZs( rezlosses.sigmoid_cross_entropyc Cs|dkrtd|dkr tdt|d|||fj}t|}t||j}|||dkr||d|d|}t j ||dd }t |||||d SQRXdS) 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 `labels`, and must be broadcastable to `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$multi_class_labels must not be None.zlogits must not be None.Zsigmoid_cross_entropy_lossrr0g?xentropy)rTrZr))rK) r rr7rGr r8r/rPrQr Z!sigmoid_cross_entropy_with_logitsrN)Zmulti_class_labelsrZr?label_smoothingrArJrKr,rrrsigmoid_cross_entropys",   rhzlosses.softmax_cross_entropyc Cs|dkrtd|dkr tdt|d|||f}t|}t||j}|||dkrtt |d|j}d|}||} ||| }t j |dd }t j ||d d } t| ||||d SQRXdS) aCreates 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(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 Nzonehot_labels must not be None.zlogits must not be None.Zsoftmax_cross_entropy_lossrg?Zlabels_stop_gradient)r)rf)rTrZr))rK)r rr7rGr r8r/rPrQrshapeZ stop_gradientr Z$softmax_cross_entropy_with_logits_v2rN) Z onehot_labelsrZr?rgrArJrKZ num_classesZsmooth_positivesZsmooth_negativesr,rrrsoftmax_cross_entropys*.    rkcstj|||d\}}dk rt|j}}|j}|dk rv|dk rv||}|dkrltdg||fStt|}|dks|dkr|j d drt t d|fddfdd||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_diffNr0rircstdgS)Nri)rsqueezer)r?rrFz/_remove_squeezable_dimensions..csS)Nrr)r?rrrnGro)r Zremove_squeezable_dimensionsrrGrPZndimsrrmr>ZdimsZis_compatible_withr Zcondr r5)rTrUr?rlZ labels_rankZ weights_shapeZ weights_rankZ rank_diffr)r?r_remove_squeezable_dimensionss(     rpz#losses.sparse_softmax_cross_entropyc Csx|dkrtd|dkr tdt|d|||f:}t|||dd\}}}tj||dd}t|||||d SQRXdS) 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 Nzlabels must not be None.zlogits must not be None.Z!sparse_softmax_cross_entropy_lossr0)rlrf)rTrZr))rK)r rr7rpr Z(sparse_softmax_cross_entropy_with_logitsrN)rTrZr?rArJrKr,rrrsparse_softmax_cross_entropyLs)rq)F)Nr)0r& __future__rrrZtensorflow.python.eagerrZtensorflow.python.frameworkrrZtensorflow.python.opsrr r r r r rZtensorflow.python.ops.lossesrZtensorflow.python.utilrZ"tensorflow.python.util.deprecationrrZ tensorflow.python.util.tf_exportrobjectrr.rBr6Zadd_dispatch_supportZ GraphKeysZLOSSESrrNrOrWrXr\r`rcrerhrkrprqrrrrs                  % *  A 1  2 / I 6 ] 1 < E 1