B ӻdq@sdZddlZddlZddlmZddlZddlmZddl m Z ddl m Z ddl m Z ddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl mZ!ddl"m#Z#ddl$m%Z%dZ&GdddeZ'ddZ(ddZ)ddZ*d d!Z+d8d#d$Z,Gd%d&d&eZ-Gd'd(d(eZ.Gd)d*d*eZ/d9d,d-Z0d.d/Z1d:d0d1Z2d2d3Z3d;d4d5Z4d6d7Z5dS).decorated)rmake_decorator)r&r'r)r&rupdate_state_wrapper@s r)csfdd}t|S)a~Decorator to wrap metric `result()` function in `merge_call()`. Result computation is an idempotent operation that simply calculates the metric value using the state variables. If metric state variables are distributed across replicas/devices and `result()` is requested from the context of one device - This function wraps `result()` in a distribution strategy `merge_call()`. With this, the metric state variables will be aggregated across devices. Args: result_fn: function that computes the metric result. Returns: Decorated function that wraps `result_fn()` in distribution strategy `merge_call()`. c st}t}|r*|dks*tjst|}t|tj t j t t fr^t|}nXt|tr|dd|D}n:yt|}Wn*ttfk rtd|j|fYnXWdQRXndd}|j|f|d}||_|S)z#Decorated function with merge_call.NcSsi|]\}}t||qSr)r identity).0keyvaluerrr sz5result_wrapper..decorated..zThe output of `metric.result()` can only be a single Tensor/Variable, or a dict of Tensors/Variables. For metric %s, got result %s.cWs||d|}t|S)Nr)Zexperimental_local_resultsr r*) distributionZmerge_fnr#resultrrrmerge_fn_wrappersz;result_wrapper..decorated..merge_fn_wrapper)r#)r has_strategyZget_replica_contextrr Z_use_merge_callZvariable_sync_on_read_context isinstancerZTensorvariables_moduleVariablefloatintr r*dictitemsr! TypeError RuntimeErrornameZ merge_callZ _call_result)r"r#r2Zreplica_contextZ raw_resultZresult_tr1) result_fnrrr'ss.      z!result_wrapper..decorated)rr()r=r'r)r=rresult_wrapper`s Or>cs8|j|jt|jt|fdd}~|S)z-Creates a weak reference to the bound method.cs||S)N)__get__)r#r$)clsfunc instance_refrrinnerszweakmethod..inner)Zim_classZim_funcweakrefrefZim_self functoolswraps)methodrCr)r@rArBr weakmethods  rIcCs,|dk r(dd|D}|r(td|dS)NcSs(g|] }|dks |dks |dkr|qS)Nrr)r+trrr sz+assert_thresholds_range..z6Threshold values must be in [0, 1]. Invalid values: {})r!format) thresholdsZinvalid_thresholdsrrrassert_thresholds_ranges rO?cCs,|dk rtt|t|dkr"|n|}|S)N)rOr )rNZdefault_thresholdrrrparse_init_thresholdss rQc@seZdZdZdZdZdZdS)ConfusionMatrixtpfptnfnN)rrrTRUE_POSITIVESFALSE_POSITIVESTRUE_NEGATIVESFALSE_NEGATIVESrrrrrRsrRc@s$eZdZdZdZdZeddZdS)AUCCurvezType of AUC Curve (ROC or PR).ROCPRcCs,|dkrtjS|dkrtjStd|dS)N)prr])Zrocr\zInvalid AUC curve value "%s".)r[r]r\r!)r,rrrfrom_strs zAUCCurve.from_strN)rrrrr\r] staticmethodr_rrrrr[sr[c@s(eZdZdZdZdZdZeddZdS)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. interpolationmajoringminoringcCs:|dkrtjS|dkrtjS|dkr*tjStd|dS)N)rb Interpolation)rcZMajoring)rdZMinoringz(Invalid AUC summation method value "%s".)ra INTERPOLATIONMAJORINGMINORINGr!)r,rrrr_ szAUCSummationMethod.from_strN) rrrrrfrgrhr`r_rrrrras  raFcs|jd|dkrd}n*ttj||jd|}|sFt|dg}|dkrTd}n*t |d}t||}|s~t|dg}t ||}t j |ddd}tt|t j|j}|st|dg}t|dg}t ||} t d||} t|dd} |rt| } t| t j} |rt| } t| } t| } fd d } t| | | f} t| | | f}ttj| d dd }ttj|d dd }n= 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 tf.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 tf.math.unsorted_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) = tf.math.floor(y_pred * num_buckets) = tf.math.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 tf.math.ceil() - 1 to achieve this. tp_bucket_value = tf.math.unsorted_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 = tf.math.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 valus 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. Returns: Update op. rNg?)dtypeg)Zclip_value_minZclip_value_maxrJcs"|d|d}}tj||dS)NrrJ)data segment_ids num_segments)runsorted_segment_sum)Zlabel_and_bucket_indexlabelZ bucket_index)num_thresholdsrr gather_bucketszC_update_confusion_matrix_variables_optimized..gather_bucketT)reverseaxis)rkrlrm)rr)rs)"shapeas_listrbroadcast_weightsrcastrir reshape expand_dimsmultiplyr Z clip_by_valuerboolceilrZreluint32Z transpose_v2parallel_control_flow_opsZvectorized_mapZcumsumrnrRrYrZ reduce_sumrWappend assign_addrXrgroup)variables_to_updatey_truey_predrN multi_labelsample_weights label_weightsthresholds_with_epsilonrZ true_labelsZ false_labelsZbucket_indicesrqZ tp_bucket_vZ fp_bucket_vrSrTZtotal_true_labelsZtotal_false_labels update_opsvariablerUrVr)rpr,_update_confusion_matrix_variables_optimizedsa                       rcCs@t|}|dkrdStj|tjd|d}tj||tdS)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 evaluted. 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. F)rirJ)Zatol)lennpZarangeZfloat32Zallcloserepsilon)rNrpZeven_thresholdsrrr is_evenly_distributed_thresholdss rc * Cs|r|dk rtd|dkr dStdd|DsJtdtt|t|dj} tj || d}tj || d}| r|ddkp|d d k} t j || d}|j d} |rtjtj d tjdt|d d } n&t||g|\\}}}tj dtjd} dd|D}|r&td|ttt tj|tj d|jdddtj|tj d |jdddgF|dkrt||\}}n$tj || d}tj|||d\}}}WdQRX|j |j |dk rt||}|dk r|d|f}|d|f}| r"tdddr"t|||||||| dSt |}|d}|j j d krHd }nt!j"|d ddd}t#| |tj$gtjd}|rt%|d}t%tj |tjdd}n,t&|d d g}t&tj |tjdd d g}|r| d d g}d ||g}| d d g}n| d g}d ||g}| d g}t't&||t(|}t'||}t)||}t'||}|dk rt*+tj || d|}t't&|||}nd}|dk r|st%|d}t*+||}t't&|||}|dkr|}n t,||}g}dd} tj-||fi}!tj.|k}"tj/|k}#tj0|k}$|$s&|"r>t1|}%||%f|!tj0<|#sJ|"rvt1|}&|&|f|!tj/<|"rv|&|%f|!tj.<x<|!2D]0\}'\}(})|'|kr|3| |(|)|||'qWt45|S)a Returns op to update 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 valus 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. Returns: Update op. 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.css|]}|ttkr|VqdS)N)listrR)r+r,rrr @sz4update_confusion_matrix_variables..z{Please provide at least one valid confusion matrix variable to update. Valid variable key options are: "{}". Received: "{}"r)rigrjg?rJZone_set_of_thresholds_cond)r<TcSsg|]}|ttkr|qSr)rrR)r+r,rrrrLesz5update_confusion_matrix_variables..z6Invalid keys: {}. Valid variable key options are: "{}"zpredictions must be >= 0)messagezpredictions must be <= 1) sample_weight.i)rrrr)inputrscSsFtjt|||jd}|dk r4|tj||jd9}|t|dS)N)rirJ)rrw logical_andrirr)ropredrvarZlabel_and_predrrrweighted_assign_adds z>update_confusion_matrix_variables..weighted_assign_add)6r!anyrMrrRkeysvaluesrirrwrZ"convert_to_tensor_v2_with_dispatchrtruequalrr}r Zrank,ragged_assert_compatible_and_get_flat_valuesr{control_dependenciesr Zassert_greater_equalZassert_less_equalrZsqueeze_or_expand_dimensionsZassert_is_compatible_with _filter_top_krZforward_compatiblerZndimsrZProdZwhere_v2ZonesryrxZtilestackZgreaterrrvrzrWrYrXrZZ logical_notr9rrr)*rrrrNtop_kZclass_idrrrZthresholds_distributed_evenlyZvariable_dtyperrpZ one_thresh_Z invalid_keysZ pred_shapeZnum_predictionsZ num_labelsZthresh_label_tileZpredictions_extra_dimZlabels_extra_dimZthresh_pretile_shapeZ thresh_tilesZ data_tilesZ thresh_tiledZ preds_tiledZ pred_is_posZ label_is_posZ weights_tiledZlabel_weights_tiledrrZ loop_varsZ update_tnZ update_fpZ update_fnZ pred_is_negZ label_is_negZ matrix_condrorrrr!update_confusion_matrix_variabless@                                rcCsLtj||dd\}}tjtj|t|ddddd}||td|S)acFilters 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. F)sortedrj)rsrJ)rrrrr Zone_hotrtNEG_INF)xkrZ top_k_idxZ top_k_maskrrrrs  rc CsJt|tr0tdd|D}tdd|D}nt|tj}|}|r|dks\t|tjrd}t|tst|g}d}dd|D}t|}t|tjrt|d |jg}t |t |j d }WdQRXg}x6|D].} t || t | j d WdQRXqW|r|d n|}n&|r,td nt|tjrBtd ||fS) aIf ragged, it checks the compatibility and then returns the flat_values. Note: If two tensors are dense, it does not check their compatibility. Note: Although two ragged tensors with different ragged ranks could have identical overall rank and dimension sizes and hence be compatible, we do not support those cases. Args: values: A list of potentially ragged tensor of the same ragged_rank. mask: A potentially ragged tensor of the same ragged_rank as elements in Values. Returns: A tuple in which the first element is the list of tensors and the second is the mask tensor. ([Values], mask). Mask and the element in Values are equal to the flat_values of the input arguments (if they were ragged). css|]}t|tjVqdS)N)r3r RaggedTensor)r+rtrrrrsz?ragged_assert_compatible_and_get_flat_values..css|]}t|tjVqdS)N)r3rr)r+rrrrrsNFTcSsg|] }|jqSr)nested_row_splits)r+rrrrrL'sz@ragged_assert_compatible_and_get_flat_values..rrjz1One of the inputs does not have acceptable types.z2Ragged mask is not allowed with non-ragged inputs.)r3rallrrr_assert_splits_matchrrrr ry flat_valuesrr:) rmaskZ is_all_raggedZ is_any_raggedZto_be_strippedZnested_row_split_listZassertion_listZassertion_list_for_maskrr-rrrrs8       " rcsJdx(D] }t|tdkr tq WfddddDS)a7Checks that the given splits lists are identical. Performs static tests to ensure that the given splits lists are identical, and returns a list of control dependency op tensors that check that they are fully identical. Args: nested_splits_lists: A list of nested_splits_lists, where each split_list is a list of `splits` tensors from a `RaggedTensor`, ordered from outermost ragged dimension to innermost ragged dimension. Returns: A list of control dependency op tensors. Raises: ValueError: If the splits are not identical. z(Inputs must have identical ragged splitsrcs4g|],}td|D]\}}tj||dqqS)r)r)zipr Z assert_equal)r+ splits_lists1s2) error_msgnested_splits_listsrrrLXsz(_assert_splits_match..rJN)rr!)rrr)rrrrBs    r)rP)FNNF)NNNFNF)N)6rrFrDenumrnumpyrZtensorflow.python.compatrZtensorflow.python.distributerZtensorflow.python.frameworkrrZtensorflow.python.kerasrZtensorflow.python.keras.utilsrr Z+tensorflow.python.keras.utils.generic_utilsr Ztensorflow.python.opsr r r rrrrrr4rZ"tensorflow.python.ops.parallel_forr~Ztensorflow.python.ops.raggedrZtensorflow.python.utilrrrr)r>rIrOrQrRr[rarrrrrrrrrrsd                      e # C p >