2VhgddlmZddlZddlmZddlmZddlmZddl m Z dZ dZ dd Z Gd d eZGd d eZGddeZ ddZdZ ddZdZ ddZy))EnumN)backend)ops)squeeze_or_expand_to_same_rank)to_listg _cl|-|Dcgc]}| |dks|dkDs|}}|rtd|yycc}w)Nrz.Threshold values must be in [0, 1]. Received: ) ValueError) thresholdstinvalid_thresholdss O/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/metrics/metrics_utils.pyassert_thresholds_ranger sd! QY!a%1q5A   /02    s11c\|tt|t||}|S|}|SN)rr)r default_thresholds rparse_init_thresholdsrsE 34'/J 6@J ceZdZdZdZdZdZy)ConfusionMatrixtpfptnfnN)__name__ __module__ __qualname__TRUE_POSITIVESFALSE_POSITIVESTRUE_NEGATIVESFALSE_NEGATIVESrrrr"sNONOrrc(eZdZdZdZdZedZy)AUCCurvezType of AUC Curve (ROC or PR).ROCPRcp|dvrtjS|dvrtjStd|d)N)prr&)rocr%zInvalid AUC curve value: "z$". Expected values are ["PR", "ROC"])r$r&r%r keys rfrom_strzAUCCurve.from_str/sD , ;;  N "<< ,SE244 rN)rrr__doc__r%r& staticmethodr,r"rrr$r$)s!( C B  rr$c,eZdZdZdZdZdZedZy)AUCSummationMethoda:Type of AUC summation method. https://en.wikipedia.org/wiki/Riemann_sum) Contains the following values: * 'interpolation': Applies mid-point summation scheme for `ROC` curve. For `PR` curve, interpolates (true/false) positives but not the ratio that is precision (see Davis & Goadrich 2006 for details). * 'minoring': Applies left summation for increasing intervals and right summation for decreasing intervals. * 'majoring': Applies right summation for increasing intervals and left summation for decreasing intervals. interpolationmajoringminoringc|dvrtjS|dvrtjS|dvrtjSt d|d)N)r1 Interpolation)r2Majoring)r3Minoringz%Invalid AUC summation method value: "z@". Expected values are ["interpolation", "majoring", "minoring"])r0 INTERPOLATIONMAJORINGMINORINGr r*s rr,zAUCSummationMethod.from_strOsa 4 4%33 3 , ,%.. . , ,%.. .7u=PP rN) rrrr-r8r9r:r.r,r"rrr0r0<s* $MHH  rr0c  tj|d|d}natjtj||jtj|}|stj |dg}|d}nXtj |d}tj|tj|}|stj |dg}tjtj|||j}tj|dd}tjtj|d|j}|s.tj |dg}tj |dg}tj||} tjd|z |} tj|tj|jd z zd z } |rtj| } tj| d } |rtj| } tj| } tj| } fd } tj| | | f} tj| | | f}tjtjtjtj| d }tjtjtjtj|d }ntj | |  } tj | |  }tjtjtj| }tjtjtj|}t"j$|vst"j&|vr[|r/tj(| d }tj(| d }n*tj(| }tj(| }t"j*|vr'|t"j*}|j-||zt"j.|vr'|t"j.}|j-||zt"j$|vr,|t"j$}|z }|j-||zt"j&|vr-|t"j&}|z }|j-||zyy)a?Update confusion matrix variables with memory efficient alternative. Note that the thresholds need to be evenly distributed within the list, eg, the diff between consecutive elements are the same. To compute TP/FP/TN/FN, we are measuring a binary classifier C(t) = (predictions >= t) at each threshold 't'. So we have TP(t) = sum( C(t) * true_labels ) FP(t) = sum( C(t) * false_labels ) But, computing C(t) requires computation for each t. To make it fast, observe that C(t) is a cumulative integral, and so if we have thresholds = [t_0, ..., t_{n-1}]; t_0 < ... < t_{n-1} where n = num_thresholds, and if we can compute the bucket function B(i) = Sum( (predictions == t), t_i <= t < t{i+1} ) then we get C(t_i) = sum( B(j), j >= i ) which is the reversed cumulative sum in ops.cumsum(). We can compute B(i) efficiently by taking advantage of the fact that our thresholds are evenly distributed, in that width = 1.0 / (num_thresholds - 1) thresholds = [0.0, 1*width, 2*width, 3*width, ..., 1.0] Given a prediction value p, we can map it to its bucket by bucket_index(p) = floor( p * (num_thresholds - 1) ) so we can use ops.segment_sum() to update the buckets in one pass. Consider following example: y_true = [0, 0, 1, 1] y_pred = [0.1, 0.5, 0.3, 0.9] thresholds = [0.0, 0.5, 1.0] num_buckets = 2 # [0.0, 1.0], (1.0, 2.0] bucket_index(y_pred) = ops.floor(y_pred * num_buckets) = ops.floor([0.2, 1.0, 0.6, 1.8]) = [0, 0, 0, 1] # The meaning of this bucket is that if any of the label is true, # then 1 will be added to the corresponding bucket with the index. # Eg, if the label for 0.2 is true, then 1 will be added to bucket 0. If the # label for 1.8 is true, then 1 will be added to bucket 1. # # Note the second item "1.0" is floored to 0, since the value need to be # strictly larger than the bucket lower bound. # In the implementation, we use ops.ceil() - 1 to achieve this. tp_bucket_value = ops.segment_sum(true_labels, bucket_indices, num_segments=num_thresholds) = [1, 1, 0] # For [1, 1, 0] here, it means there is 1 true value contributed by bucket # 0, and 1 value contributed by bucket 1. When we aggregate them to # together, the result become [a + b + c, b + c, c], since large thresholds # will always contribute to the value for smaller thresholds. true_positive = ops.cumsum(tp_bucket_value, reverse=True) = [2, 1, 0] This implementation exhibits a run time and space complexity of O(T + N), where T is the number of thresholds and N is the size of predictions. Metrics that rely on standard implementation instead exhibit a complexity of O(T * N). Args: variables_to_update: Dictionary with 'tp', 'fn', 'tn', 'fp' as valid keys and corresponding variables to update as values. y_true: A floating point `Tensor` whose shape matches `y_pred`. Will be cast to `bool`. y_pred: A floating point `Tensor` of arbitrary shape and whose values are in the range `[0, 1]`. thresholds: A sorted floating point `Tensor` with value in `[0, 1]`. It need to be evenly distributed (the diff between each element need to be the same). multi_label: Optional boolean indicating whether multidimensional prediction/labels should be treated as multilabel responses, or flattened into a single label. When True, the values of `variables_to_update` must have a second dimension equal to the number of labels in y_true and y_pred, and those tensors must not be RaggedTensors. sample_weights: Optional `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true` (i.e., all dimensions must be either `1`, or the same as the corresponding `y_true` dimension). label_weights: Optional tensor of non-negative weights for multilabel data. The weights are applied when calculating TP, FP, FN, and TN without explicit multilabel handling (i.e. when the data is to be flattened). thresholds_with_epsilon: Optional boolean indicating whether the leading and tailing thresholds has any epsilon added for floating point imprecisions. It will change how we handle the leading and tailing bucket. rN?dtype)x_minx_maxboolr int32cH|d|d}}tj||S)Nrr data segment_ids num_segments)r segment_sum)label_and_bucket_indexlabel bucket_indexnum_thresholdss r gather_bucketzC_update_confusion_matrix_variables_optimized..gather_buckets6&q)&q) E??(+ raxisrF)rshape broadcast_tocastr>reshape expand_dimsmultiplyclipceilrelu transposervectorized_mapflipcumsumrJrr r!sumrassignr)variables_to_updatey_truey_predr multi_labelsample_weights label_weightsthresholds_with_epsilonweights true_labels false_labelsbucket_indicesrO tp_bucket_v fp_bucket_vrrtotal_true_labelstotal_false_labelsvariablerrrNs @r,_update_confusion_matrix_variables_optimizedrq^sDYYz*1-N)) HH^6<< 8#))F:K  [[">N  q9 (( &8IJ KK t  # 4 !$!6 %%)<<&'E'EF2 &&&*==&'F'FG2 &%%)<<&'E'EF " $2 &&&*==&'F'FG  #2 &>rct|}|dkrytj|tj|dz z }tj||t j S)aCheck if the thresholds list is evenly distributed. We could leverage evenly distributed thresholds to use less memory when calculate metrcis like AUC where each individual threshold need to be evaluated. Args: thresholds: A python list or tuple, or 1D numpy array whose value is ranged in [0, 1]. Returns: boolean, whether the values in the inputs are evenly distributed. Fr=r )atol)lennparangefloat32allcloserepsilon)r rNeven_thresholdss r is_evenly_distributed_thresholdsr|:sU_NiibjjAO ;;z?9J KKrc  |r | td|ytd|Ds-tdttd|j dt|j dj } tj|| }tj|| }| r|dd kxs|d d kD} tj|| }tj|d} |r?tjtjd d t|j} ntjdd} |Dcgc]}|ttvs|}}|rtd|dttdt||\}}|=tj tj|| d }t||d\}}| t#||}|@t|jd k(rtd|j|d|df}|d|df}| rt%||||||| Sd|jvrtj|}|d}t|jd k(rd }nAtjtj&tj|d ddd }tj(| |d }nutj|}|d}t|jd k(rd }n)tj&|d ddj+d }tj(| |d }|rBtj |d}tj tj|dd}nEtj,|d d g}tj,tj|dd d g}|r| d d g}d ||g}| d d g}n| d g}d ||zg}| d g}tj.tj,|||}tj.||}tj0||}tj.||}|stj2tj||j tj|}tj.tj,|||}nd}||stj |d}tj2|tj|}tj.tj,|||}||}ntj4||}d} tj6||fi}!tj8|v}"tj:|v}#tj<|v}$|$s|"r*tj>|}%||%f|!tj<<|#s|"rAtj>|}&|&|f|!tj:<|"r|&%f|!tj8<|!jAD]\}'\}(})|'|vs| |(|)|||'ycc}w)a Updates the given confusion matrix variables. For every pair of values in y_true and y_pred: true_positive: y_true == True and y_pred > thresholds false_negatives: y_true == True and y_pred <= thresholds true_negatives: y_true == False and y_pred <= thresholds false_positive: y_true == False and y_pred > thresholds The results will be weighted and added together. When multiple thresholds are provided, we will repeat the same for every threshold. For estimation of these metrics over a stream of data, the function creates an `update_op` operation that updates the given variables. If `sample_weight` is `None`, weights default to 1. Use weights of 0 to mask values. Args: variables_to_update: Dictionary with 'tp', 'fn', 'tn', 'fp' as valid keys and corresponding variables to update as values. y_true: A `Tensor` whose shape matches `y_pred`. Will be cast to `bool`. y_pred: A floating point `Tensor` of arbitrary shape and whose values are in the range `[0, 1]`. thresholds: A float value, float tensor, python list, or tuple of float thresholds in `[0, 1]`, or NEG_INF (used when top_k is set). top_k: Optional int, indicates that the positive labels should be limited to the top k predictions. class_id: Optional int, limits the prediction and labels to the class specified by this argument. sample_weight: Optional `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true` (i.e., all dimensions must be either `1`, or the same as the corresponding `y_true` dimension). multi_label: Optional boolean indicating whether multidimensional prediction/labels should be treated as multilabel responses, or flattened into a single label. When True, the values of `variables_to_update` must have a second dimension equal to the number of labels in y_true and y_pred, and those tensors must not be RaggedTensors. label_weights: (optional) tensor of non-negative weights for multilabel data. The weights are applied when calculating TP, FP, FN, and TN without explicit multilabel handling (i.e. when the data is to be flattened). thresholds_distributed_evenly: Boolean, whether the thresholds are evenly distributed within the list. An optimized method will be used if this is the case. See _update_confusion_matrix_variables_optimized() for more details. Raises: ValueError: If `y_pred` and `y_true` have mismatched shapes, or if `sample_weight` is not `None` and its shape doesn't match `y_pred`, or if `variables_to_update` contains invalid keys. Nz`label_weights` for multilabel data should be handled outside of `update_confusion_matrix_variables` when `multi_label` is True.c3DK|]}|ttvs|ywr)listr).0r+s r z4update_confusion_matrix_variables..s!cT/5J.Js  zhPlease provide at least one valid confusion matrix variable to update. Valid variable key options are: "z". Received: ""rr=r@r?r<r rDTrCzInvalid keys: "z$". Valid variable key options are: "rPF) expand_rank_1ziWhen class_id is provided, y_pred must be a 2D array with shape (num_samples, num_classes), found shape: .)rdrerfrgc tjtj|||j}|$|tj||jz}|j |tj |dzy)Nr=r )rrT logical_andr>r`r_)rLpredrhvarlabel_and_preds rweighted_assign_addz>update_confusion_matrix_variables..weighted_assign_add4s\#//%">ciiP   chhwcii@ @N 3334r)!r anyrrkeysvaluesr>rrTconvert_to_tensorrRequalrvarrayrurrV _filter_top_krqprodwhereastyperUtilegreaterrSrWrr rr! logical_notitems)*rarbrcr top_kclass_id sample_weightrdrfthresholds_distributed_evenlyvariable_dtypergrN one_threshr+ invalid_keys_ pred_shapenum_predictions num_labelsthresh_label_tilepredictions_extra_dimlabels_extra_dimthresh_pretile_shape thresh_tiles data_tiles thresh_tiled preds_tiled pred_is_pos label_is_pos weights_tiledlabel_weights_tiledr loop_vars update_tn update_fp update_fn pred_is_neg label_is_neg matrix_condrLrs* r!update_confusion_matrix_variablesrRs;D}0 %  " *  _%&'-2245Q 8  -4467:@@N XXfN 3F XXfN 3F$#-Q-#"5"MB#9M&&zHJYYz*1-NYY HHQg &    ! XXd&1 +co9N.NLl^,004_0E/Fa I  4FFCNFF  HH]. 9 : M = vu- v||  !G<<." Xt+,Xt+,$;    #('$;   v||YYv& $Q- v||  !J:ab>2;WJ IIj*a@YYv& $Q- v||  !JABa8??HJHHZQ? # :??388F&+I1M!$ FQG <;;sxxf'E2wO .26?,=> $a+ .3?Z78 $a( 88 J 45|L ((0*=K++k<8K88,j9L (( HH]&,, 769J  KK | 4j    q9 (( &8IJ !hh KK | 4j   /MLL8KLM5 &&{(CI ..2EEI//3FFI//3FFIIook2 6BK5P /112I|4 6BK5P /112 9Io44 5 '0oo&7" ]eT - - t],? ,L _s Y Y ctj||\}}tjtj|tj|ddd}||zt d|z zzS)asFilters top-k values in the last dim of x and set the rest to NEG_INF. Used for computing top-k prediction values in dense labels (which has the same shape as predictions) for recall and precision top-k metrics. Args: x: tensor with any dimensions. k: the number of values to keep. Returns: tensor with same shape and dtype as x. r?rPr )rrr_one_hotrRNEG_INF)xkr top_k_idx top_k_masks rrrUs^99Q?LAy Isyy|B/b9J z>Gq:~6 66rctj||}tj||}t||\}}tj||}tj||}|tj||}tj||gd}|tj ||n|}tj|d}tj||}t |}tj||||f}|S)aComputes the confusion matrix from predictions and labels. The matrix columns represent the prediction labels and the rows represent the real labels. The confusion matrix is always a 2-D array of shape `(n, n)`, where `n` is the number of valid labels for a given classification task. Both prediction and labels must be 1-D arrays of the same shape in order for this function to work. If `num_classes` is `None`, then `num_classes` will be set to one plus the maximum value in either predictions or labels. Class labels are expected to start at 0. For example, if `num_classes` is 3, then the possible labels would be `[0, 1, 2]`. If `weights` is not `None`, then each prediction contributes its corresponding weight to the total value of the confusion matrix cell. For example: ```python keras.metrics.metrics_utils.confusion_matrix([1, 2, 4], [2, 2, 4]) ==> [[0 0 0 0 0] [0 0 1 0 0] [0 0 1 0 0] [0 0 0 0 0] [0 0 0 0 1]] ``` Note that the possible labels are assumed to be `[0, 1, 2, 3, 4]`, resulting in a 5x5 confusion matrix. Args: labels: 1-D tensor of real labels for the classification task. predictions: 1-D tensor of predictions for a given classification. num_classes: The possible number of labels the classification task can have. weights: An optional tensor whose shape matches `predictions`. dtype: Data type of the confusion matrix. Returns: A tensor of type `dtype` with shape `(n, n)` representing the confusion matrix, where `n` is the number of possible labels in the classification task. r rPint64r=)rrrrTstack ones_likeintscatter)labels predictions num_classesrhr>indicesrconfusion_matrixs rrrisd " "65 1F'' U;K8MFK((;.K XXfe $F''7ii-A6G29/S]]; .wFhhwg.G XXfE *Fk"K{{7F[+4NO r)g?)FNNF)NNNFNF)NrD)enumrnumpyrv keras.srcrrkeras.src.losses.lossrkeras.src.utils.python_utilsrrrrrr$r0rqr|rrrr"rrrs@0  dt&N!Y'xL:  "'@F70   Br