o Ne@s4dZddlmZddlZddlZddlZddlZddlm Z ddl m Z ddl m Z ddlmZmZmZdd l mZdd lmZgd Zd d ZddZddZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGd d!d!eZ Gd"d#d#eZ!dS)$z Fluid Metrics )print_functionN) LayerHelper)Constant) unique_name)ProgramVariable program_guard)layers) detection) MetricBaseCompositeMetric PrecisionRecallAccuracyChunkEvaluator EditDistance DetectionMAPAuccCst|tjtjfSN) isinstancenpndarraygenericvarrDD:\Projects\ConvertPro\env\Lib\site-packages\paddle/fluid/metrics.py _is_numpy_-srcCs6t|tpt|tjpt|tpt|tjo|jdkS)N)r)rintrZint64floatrshaperrrr _is_number_1s r"cCst|p t|tjSr)r"rrrrrrr_is_number_or_matrix_6sr#c@s@eZdZdZddZddZddZdd Zd d Zd d Z dS)r a In many cases, we usually have to split the test data into mini-batches for evaluating deep neural networks, therefore we need to collect the evaluation results of each mini-batch and aggregate them into the final result. The paddle.fluid.metrics is designed for a convenient way of deep neural network evaluation. The paddle.fluid.metrics contains serval different evaluation metrics like precision and recall, and most of them have the following functions: 1. take the prediction result and the corresponding labels of a mini-batch as input, then compute the evaluation result for the input mini-batch. 2. aggregate the existing evaluation results as the overall performance. The class Metric is the base class for all classes in paddle.fluid.metrics, it defines the fundamental APIs for all metrics classes, including: 1. update(preds, labels): given the prediction results (preds) and the labels (labels) of some mini-batch, compute the evaluation result of that mini-batch, and memorize the evaluation result. 2. eval(): aggregate all existing evaluation result in the memory, and return the overall performance across different mini-batches. 3. reset(): empty the memory. cCs$|dkr t||_dS|jj|_dS)am The constructor of the metric class. Args: name(str): The name of metric instance. such as, "accuracy". It can be used to distinguish different metric instances in a model. Returns: The constructed class instance. Return types: The MetricBase or its succeed classes N)str __class____name___nameselfnamerrr__init__Ws$zMetricBase.__init__cCs|jSr)r'r)rrr__str__hszMetricBase.__str__cCsddt|jD}t|D]5\}}t|tr t||dqt|tr,t||dqt|tjtj fr?t||t |qt||dqdS)z reset function empties the evaluation memory for previous mini-batches. Args: None Returns: None Return types: None cS i|] \}}|ds||qS_ startswith.0attrvaluerrr y z$MetricBase.reset..rN) six iteritems__dict__rrsetattrr rrrZ zeros_like)r)statesr5r6rrrresetks   zMetricBase.resetcCs6ddt|jD}i}||jt|d|S)a' Get the metric and current states. The states are the members who do not has "_" prefix. Args: None Returns: a python dict, which contains the inner states of the metric instance Return types: a python dict cSr.r/r1r3rrrr7r8z)MetricBase.get_config..)r*r>)r:r;r<updater'copydeepcopy)r)r>configrrr get_configs  zMetricBase.get_configcCtd)ao Given the prediction results (preds) and the labels (labels) of some mini-batch, compute the evaluation result of that mini-batch, and memorize the evaluation result. Please notice that the update function only memorizes the evaluation result but would not return the score. If you want to get the evaluation result, please call eval() function. Args: preds(numpy.array): the predictions of current minibatch labels(numpy.array): the labels of current minibatch. Returns: None Return types: None -Should not use it directly, please extend it.NotImplementedError)r)predslabelsrrrr@szMetricBase.updatecCrE)ac Aggregate all existing evaluation results in the memory, and return the overall performance across different mini-batches. Args: None Returns: The overall performance across different mini-batches. Return types: float|list(float)|numpy.array: the metrics via Python. rFrGr,rrrevalszMetricBase.evalN) r& __module__ __qualname____doc__r+r-r?rDr@rKrrrrr :s r cs:eZdZdZd fdd ZddZddZd d ZZS) r a This op creates a container that contains the union of all the added metrics. After the metrics added in, calling eval() method will compute all the contained metrics automatically. CAUTION: only metrics with the SAME argument list can be added in a CompositeMetric instance. Inherit from: `MetricBase `_ Args: name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np preds = [[0.1], [0.7], [0.8], [0.9], [0.2], [0.2], [0.3], [0.5], [0.8], [0.6]] labels = [[0], [1], [1], [1], [1], [0], [0], [0], [0], [0]] preds = np.array(preds) labels = np.array(labels) comp = fluid.metrics.CompositeMetric() precision = fluid.metrics.Precision() recall = fluid.metrics.Recall() comp.add_metric(precision) comp.add_metric(recall) comp.update(preds=preds, labels=labels) numpy_precision, numpy_recall = comp.eval() print("expect precision: %.2f, got %.2f" % ( 3. / 5, numpy_precision ) ) print("expect recall: %.2f, got %.2f" % (3. / 4, numpy_recall ) ) Ncstt||g|_dSr)superr r+_metricsr(r%rrr+s zCompositeMetric.__init__cCs"t|ts td|j|dS)z Add a new metric to container. Noted that the argument list of the added one should be consistent with existed ones. Args: metric(MetricBase): a instance of MetricBase z,SubMetric should be inherit from MetricBase.N)rr ValueErrorrPappend)r)Zmetricrrr add_metrics zCompositeMetric.add_metriccCs|jD]}|||qdS)a Update the metrics of this container. Args: preds(numpy.array): predicted results of current mini-batch, the shape and dtype of which should meet the requirements of the corresponded metric. labels(numpy.array): ground truth of current mini-batch, the shape and dtype of which should meet the requirements of the corresponded metric. N)rPr@)r)rIrJmrrrr@s zCompositeMetric.updatecCs"g}|jD] }||q|S)z Calculate the results of all metrics sequentially. Returns: list: results of all added metrics. The shape and dtype of each result depend on the definition of its metric. )rPrSrK)r)ZansrUrrrrKs zCompositeMetric.evalr) r&rLrMrNr+rTr@rK __classcell__rrrQrr s   r c2eZdZdZd fdd ZddZddZZS) raR Precision (also called positive predictive value) is the fraction of relevant instances among the retrieved instances. Refer to https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers Noted that this class manages the precision score only for binary classification task. Args: name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np metric = fluid.metrics.Precision() # generate the preds and labels preds = [[0.1], [0.7], [0.8], [0.9], [0.2], [0.2], [0.3], [0.5], [0.8], [0.6]] labels = [[0], [1], [1], [1], [1], [0], [0], [0], [0], [0]] preds = np.array(preds) labels = np.array(labels) metric.update(preds=preds, labels=labels) numpy_precision = metric.eval() print("expect precision: %.2f and got %.2f" % ( 3.0 / 5.0, numpy_precision)) Nc tt||d|_d|_dSNr)rOrr+tpfpr(rQrrr+4 zPrecision.__init__cCst|stdt|std|jd}t|d}t|D]!}||}||}|dkrB||kr;|jd7_q!|jd7_q!dS)aI Update the precision based on the current mini-batch prediction results . Args: preds(numpy.ndarray): prediction results of current mini-batch, the output of two-class sigmoid function. Shape: [batch_size, 1]. Dtype: 'float64' or 'float32'. labels(numpy.ndarray): ground truth (labels) of current mini-batch, the shape should keep the same as preds. Shape: [batch_size, 1], Dtype: 'int32' or 'int64'. $The 'preds' must be a numpy ndarray.%The 'labels' must be a numpy ndarray.rint32rN) rrRr!rrintastyperangerZr[r)rIrJZ sample_numipredlabelrrrr@9   zPrecision.updatecC&|j|j}|dkrt|j|SdS)z Calculate the final precision. Returns: float: Results of the calculated Precision. Scalar output with float dtype. rr9)rZr[r )r)ZaprrrrKU zPrecision.evalrr&rLrMrNr+r@rKrVrrrQrrs #rcrW) raX Recall (also known as sensitivity) is the fraction of relevant instances that have been retrieved over the total amount of relevant instances Refer to: https://en.wikipedia.org/wiki/Precision_and_recall Noted that this class manages the recall score only for binary classification task. Args: name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np metric = fluid.metrics.Recall() # generate the preds and labels preds = [[0.1], [0.7], [0.8], [0.9], [0.2], [0.2], [0.3], [0.5], [0.8], [0.6]] labels = [[0], [1], [1], [1], [1], [0], [0], [0], [0], [0]] preds = np.array(preds) labels = np.array(labels) metric.update(preds=preds, labels=labels) numpy_recall = metric.eval() print("expect recall: %.2f and got %.2f" % ( 3.0 / 4.0, numpy_recall)) NcrXrY)rOrr+rZfnr(rQrrr+r\zRecall.__init__cCst|stdt|std|jd}t|d}t|D]!}||}||}|dkrB||kr;|jd7_q!|jd7_q!dS)a9 Update the recall based on the current mini-batch prediction results. Args: preds(numpy.array): prediction results of current mini-batch, the output of two-class sigmoid function. Shape: [batch_size, 1]. Dtype: 'float64' or 'float32'. labels(numpy.array): ground truth (labels) of current mini-batch, the shape should keep the same as preds. Shape: [batch_size, 1], Dtype: 'int32' or 'int64'. r]r^rr_rN) rrRr!rr`rarbrZrkrcrrrr@rgz Recall.updatecCrh)z Calculate the final recall. Returns: float: results of the calculated Recall. Scalar output with float dtype. rr9)rZrkr )r)recallrrrrKriz Recall.evalrrjrrrQrr`s &rcrW) rak This interface is used to calculate the mean accuracy over multiple batches. Accuracy object has two state: value and weight. The definition of Accuracy is available at https://en.wikipedia.org/wiki/Accuracy_and_precision Args: name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None. Examples: .. code-block:: python import paddle.fluid as fluid #suppose we have batch_size = 128 batch_size=128 accuracy_manager = fluid.metrics.Accuracy() #suppose the accuracy is 0.9 for the 1st batch batch1_acc = 0.9 accuracy_manager.update(value = batch1_acc, weight = batch_size) print("expect accuracy: %.2f, get accuracy: %.2f" % (batch1_acc, accuracy_manager.eval())) #suppose the accuracy is 0.8 for the 2nd batch batch2_acc = 0.8 accuracy_manager.update(value = batch2_acc, weight = batch_size) #the joint acc for batch1 and batch2 is (batch1_acc * batch_size + batch2_acc * batch_size) / batch_size / 2 print("expect accuracy: %.2f, get accuracy: %.2f" % ((batch1_acc * batch_size + batch2_acc * batch_size) / batch_size / 2, accuracy_manager.eval())) #reset the accuracy_manager accuracy_manager.reset() #suppose the accuracy is 0.8 for the 3rd batch batch3_acc = 0.8 accuracy_manager.update(value = batch3_acc, weight = batch_size) print("expect accuracy: %.2f, get accuracy: %.2f" % (batch3_acc, accuracy_manager.eval())) NcrX)Nr9)rOrr+r6weightr(rQrrr+r\zAccuracy.__init__cCs\t|stdt|stdt|r|dkrtd|j||7_|j|7_dS)a This function takes the minibatch states (value, weight) as input, to accumulate and update the corresponding status of the Accuracy object. The update method is as follows: .. math:: \\\\ \\begin{array}{l}{\\text { self. value }+=\\text { value } * \\text { weight }} \\\\ {\\text { self. weight }+=\\text { weight }}\\end{array} \\\\ Args: value(float|numpy.array): accuracy of one minibatch. weight(int|float): minibatch size. z`_ . ChunkEvalEvaluator computes the precision, recall, and F1-score of chunk detection, and supports IOB, IOE, IOBES and IO (also known as plain) tagging schemes. Args: name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None. Examples: .. code-block:: python import paddle.fluid as fluid # init the chunk-level evaluation manager metric = fluid.metrics.ChunkEvaluator() # suppose the model predict 10 chucks, while 8 ones are correct and the ground truth has 9 chucks. num_infer_chunks = 10 num_label_chunks = 9 num_correct_chunks = 8 metric.update(num_infer_chunks, num_label_chunks, num_correct_chunks) numpy_precision, numpy_recall, numpy_f1 = metric.eval() print("precision: %.2f, recall: %.2f, f1: %.2f" % (numpy_precision, numpy_recall, numpy_f1)) # the next batch, predicting 3 perfectly correct chucks. num_infer_chunks = 3 num_label_chunks = 3 num_correct_chunks = 3 metric.update(num_infer_chunks, num_label_chunks, num_correct_chunks) numpy_precision, numpy_recall, numpy_f1 = metric.eval() print("precision: %.2f, recall: %.2f, f1: %.2f" % (numpy_precision, numpy_recall, numpy_f1)) Ncs&tt||d|_d|_d|_dSrY)rOrr+num_infer_chunksnum_label_chunksnum_correct_chunksr(rQrrr+- zChunkEvaluator.__init__cCs^t|stdt|stdt|std|j|7_|j|7_|j|7_dS)a This function takes (num_infer_chunks, num_label_chunks, num_correct_chunks) as input, to accumulate and update the corresponding status of the ChunkEvaluator object. The update method is as follows: .. math:: \\\\ \\begin{array}{l}{\\text { self. num_infer_chunks }+=\\text { num_infer_chunks }} \\\\ {\\text { self. num_Label_chunks }+=\\text { num_label_chunks }} \\\\ {\\text { self. num_correct_chunks }+=\\text { num_correct_chunks }}\\end{array} \\\\ Args: num_infer_chunks(int|numpy.array): The number of chunks in Inference on the given minibatch. num_label_chunks(int|numpy.array): The number of chunks in Label on the given mini-batch. num_correct_chunks(int|float|numpy.array): The number of chunks both in Inference and Label on the given mini-batch. z@The 'num_infer_chunks' must be a number(int) or a numpy ndarray.zGThe 'num_label_chunks' must be a number(int, float) or a numpy ndarray.zIThe 'num_correct_chunks' must be a number(int, float) or a numpy ndarray.N)r#rRrnrorp)r)rnrorprrrr@3szChunkEvaluator.updatecCs`|jr t|j|jnd}|jrt|j|jnd}|jr)td||||nd}|||fS)z This function returns the mean precision, recall and f1 score for all accumulated minibatches. Returns: float: mean precision, recall and f1 score. r)rnr rpro)r) precisionrlZf1_scorerrrrKQs*   zChunkEvaluator.evalrrjrrrQrrs +rcs0eZdZdZfddZddZddZZS)ra This API is for the management of edit distances. Editing distance is a method to quantify the degree of dissimilarity between two strings, such as words, by calculating the minimum editing operand (add, delete or replace) required to convert one string into another. Refer to https://en.wikipedia.org/wiki/Edit_distance. Args: name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np # suppose that batch_size is 128 batch_size = 128 # init the edit distance manager distance_evaluator = fluid.metrics.EditDistance("EditDistance") # generate the edit distance across 128 sequence pairs, the max distance is 10 here edit_distances_batch0 = np.random.randint(low = 0, high = 10, size = (batch_size, 1)) seq_num_batch0 = batch_size distance_evaluator.update(edit_distances_batch0, seq_num_batch0) avg_distance, wrong_instance_ratio = distance_evaluator.eval() print("the average edit distance for batch0 is %.2f and the wrong instance ratio is %.2f " % (avg_distance, wrong_instance_ratio)) edit_distances_batch1 = np.random.randint(low = 0, high = 10, size = (batch_size, 1)) seq_num_batch1 = batch_size distance_evaluator.update(edit_distances_batch1, seq_num_batch1) avg_distance, wrong_instance_ratio = distance_evaluator.eval() print("the average edit distance for batch0 and batch1 is %.2f and the wrong instance ratio is %.2f " % (avg_distance, wrong_instance_ratio)) distance_evaluator.reset() edit_distances_batch2 = np.random.randint(low = 0, high = 10, size = (batch_size, 1)) seq_num_batch2 = batch_size distance_evaluator.update(edit_distances_batch2, seq_num_batch2) avg_distance, wrong_instance_ratio = distance_evaluator.eval() print("the average edit distance for batch2 is %.2f and the wrong instance ratio is %.2f " % (avg_distance, wrong_instance_ratio)) cs&tt||d|_d|_d|_dS)Nr9r)rOrr+total_distanceseq_numinstance_errorr(rQrrr+rqzEditDistance.__init__cCsjt|stdt|stdt|dk}t|}|j|7_|j||7_|j|7_dS)a Update the overall edit distance Args: distances(numpy.array): a (batch_size, 1) numpy.array, each element represents the edit distance between two sequences. seq_num(int|float): standing for the number of sequence pairs. z(The 'distances' must be a numpy ndarray.z+The 'seq_num' must be a number(int, float).rN)rrRr"rsumrurvrt)r)Z distancesruZseq_right_countrtrrrr@s zEditDistance.updatecCs6|jdkr td|j|j}|jt|j}||fS)z Return two floats: avg_distance: the average distance for all sequence pairs updated using the update function. avg_instance_error: the ratio of sequence pairs whose edit distance is not zero. rzqThere is no data in EditDistance Metric. Please check layers.edit_distance output has been added to EditDistance.)rurRrtrvr )r)Z avg_distanceZavg_instance_errorrrrrKs  zEditDistance.evalrjrrrQrrcs  0rcs>eZdZdZd fdd ZddZedd Zd d ZZ S) ra The auc metric is for binary classification. Refer to https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve. Please notice that the auc metric is implemented with python, which may be a little bit slow. If you concern the speed, please use the fluid.layers.auc instead. The `auc` function creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the AUC. To discretize the AUC curve, a linearly spaced set of thresholds is used to compute pairs of recall and precision values. The area under the ROC-curve is therefore computed using the height of the recall values by the false positive rate, while the area under the PR-curve is the computed using the height of the precision values by the recall. Args: name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None. curve (str): Specifies the name of the curve to be computed, 'ROC' [default] or 'PR' for the Precision-Recall-curve. "NOTE: only implement the ROC curve type via Python now." Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np # init the auc metric auc_metric = fluid.metrics.Auc("ROC") # suppose that batch_size is 128 batch_num = 100 batch_size = 128 for batch_id in range(batch_num): class0_preds = np.random.random(size = (batch_size, 1)) class1_preds = 1 - class0_preds preds = np.concatenate((class0_preds, class1_preds), axis=1) labels = np.random.randint(2, size = (batch_size, 1)) auc_metric.update(preds = preds, labels = labels) # shall be some score closing to 0.5 as the preds are randomly assigned print("auc for iteration %d is %.2f" % (batch_id, auc_metric.eval())) ROCcsBtt|j|d||_||_|d}dg||_dg||_dS)N)r*rr)rOrr+Z_curve_num_thresholds _stat_pos _stat_neg)r)r*ZcurveZnum_thresholdsZ_num_pred_bucketsrQrrr+s  z Auc.__init__cCst|stdt|stdt|D]-\}}||df}t||j}||jks,J|r8|j|d7<q|j|d7<qdS)a Update the auc curve with the given predictions and labels. Args: preds (numpy.array): an numpy array in the shape of (batch_size, 2), preds[i][j] denotes the probability of classifying the instance i into the class j. labels (numpy.array): an numpy array in the shape of (batch_size, 1), labels[i] is either o or 1, representing the label of the instance i. r^z*The 'predictions' must be a numpy ndarray.rg?N)rrR enumeraterrzr{r|)r)rIrJrdZlblr6Zbin_idxrrrr@s z Auc.updatecCst||||dS)Ng@)abs)x1Zx2y1y2rrrtrapezoid_area szAuc.trapezoid_areacCsd}d}d}|j}|dkr1|}|}||j|7}||j|7}||||||7}|d8}|dks |dkr?|dkr?|||SdS)z~ Return the area (a float score) under auc curve Return: float: the area under auc curve r9rr)rzr{r|r)r)Ztot_posZtot_negZaucidxZ tot_pos_prevZ tot_neg_prevrrrrK s  zAuc.eval)rxry) r&rLrMrNr+r@ staticmethodrrKrVrrrQrrs.  rc@s@eZdZdZ      dddZd d Zd d Zdd dZdS)ra& Calculate the detection mean average precision (mAP). The general steps are as follows: 1. calculate the true positive and false positive according to the input of detection and labels. 2. calculate mAP value, support two versions: '11 point' and 'integral'. 11point: the 11-point interpolated average precision. integral: the natural integral of the precision-recall curve. Please get more information from the following articles: https://sanchom.wordpress.com/tag/average-precision/ https://arxiv.org/abs/1512.02325 Args: input (Variable): LoDTensor, The detection results, which is a LoDTensor with shape [M, 6]. The layout is [label, confidence, xmin, ymin, xmax, ymax]. The data type is float32 or float64. gt_label (Variable): LoDTensor, The ground truth label index, which is a LoDTensor with shape [N, 1].The data type is float32 or float64. gt_box (Variable): LoDTensor, The ground truth bounding box (bbox), which is a LoDTensor with shape [N, 4]. The layout is [xmin, ymin, xmax, ymax]. The data type is float32 or float64. gt_difficult (Variable|None): LoDTensor, Whether this ground truth is a difficult bounding bbox, which can be a LoDTensor [N, 1] or not set. If None, it means all the ground truth labels are not difficult bbox.The data type is int. class_num (int): The class number. background_label (int): The index of background label, the background label will be ignored. If set to -1, then all categories will be considered, 0 by default. overlap_threshold (float): The threshold for deciding true/false positive, 0.5 by default. evaluate_difficult (bool): Whether to consider difficult ground truth for evaluation, True by default. This argument does not work when gt_difficult is None. ap_version (str): The average precision calculation ways, it must be 'integral' or '11point'. Please check https://sanchom.wordpress.com/tag/average-precision/ for details. Examples: .. code-block:: python import paddle.fluid as fluid import paddle paddle.enable_static() batch_size = None # can be any size image_boxs_num = 10 bounding_bboxes_num = 21 pb = fluid.data(name='prior_box', shape=[image_boxs_num, 4], dtype='float32') pbv = fluid.data(name='prior_box_var', shape=[image_boxs_num, 4], dtype='float32') loc = fluid.data(name='target_box', shape=[batch_size, bounding_bboxes_num, 4], dtype='float32') scores = fluid.data(name='scores', shape=[batch_size, bounding_bboxes_num, image_boxs_num], dtype='float32') nmsed_outs = fluid.layers.detection_output(scores=scores, loc=loc, prior_box=pb, prior_box_var=pbv) gt_box = fluid.data(name="gt_box", shape=[batch_size, 4], dtype="float32") gt_label = fluid.data(name="gt_label", shape=[batch_size, 1], dtype="float32") difficult = fluid.data(name="difficult", shape=[batch_size, 1], dtype="float32") exe = fluid.Executor(fluid.CUDAPlace(0)) map_evaluator = fluid.metrics.DetectionMAP(nmsed_outs, gt_label, gt_box, difficult, class_num = 3) cur_map, accum_map = map_evaluator.get_map_var() Nr?Tintegralc  Cs2td|_tj||jd}|r"tj||jd}tj|||gdd} n tj||gdd} tj|| ||||| d} g} | |j dddd| |j d dd d| |j d dd d|j ddgd d} |jj | t t d dd| |_ tj|| |||||j | | | d }tj|j jd|j j|j d| |_||_dS)NZmap_eval)xdtyper)Zaxis)overlap_thresholdevaluate_difficult ap_versionr_Zaccum_pos_count)rr!suffixZfloat32Zaccum_true_posZaccum_false_pos has_stater)r6) initializer)rrrZ input_statesZ out_statesrr!r6rout)rhelperr castrconcatr Z detection_maprS _create_stateZset_variable_initializerrrr fill_constantr!cur_map accum_map)r)inputZgt_labelZgt_boxZ gt_difficultZ class_numZbackground_labelrrrrfmapr>rrrrrr+xsr    zDetectionMAP.__init__cCs,|jjdt|jj|gd||d}|S)z Create state variable. Args: suffix(str): the state suffix. dtype(str|core.VarDesc.VarType): the state data type shape(tuple|list): the shape of state Returns: State variable r0T)r* persistablerr!)rZcreate_variablejoinrgenerater*)r)rrr!staterrrrs zDetectionMAP._create_statecCs |j|jfS)z{ Returns: mAP variable of current mini-batch and accumulative mAP variable cross mini-batches. )rrr,rrr get_map_vars zDetectionMAP.get_map_varcCstdd}|dur t}t|d|||j}tj|jd|j|dWdn1s.wY||dS)a< Reset metric states at the begin of each pass/user specified batch. Args: executor(Executor): a executor for executing the reset_program. reset_program(Program|None): a single Program for reset process. If None, will create a Program. cSs0t|tsJ|j|j|j|j|j|j|jdS)N)r*r!rtype lod_levelr) rrZ create_varr*r!rrrr)blockrrrr _clone_var_sz'DetectionMAP.reset.._clone_var_N)Z main_programrr) rr Z current_blockrr rr!rrun)r)executorZ reset_programrrrrrr?s   zDetectionMAP.reset)NNrrTrr)r&rLrMrNr+rrr?rrrrr%sV Cr)"rN __future__rnumpyrrAwarningsr:Z layer_helperrrrrZ frameworkrrr r r __all__rr"r#objectr r rrrrrrrrrrrs4       IPSNbXj