Ng{0ddlTddlTGddZdS))*cpeZdZdZ ddZ ddZ dd Z dd Z dd Zd Z d Z ddZ dZ ddZ dS)PerImageEvaluationz,Evaluate detection result of a single image.?333333?2cL||_||_||_||_||_dS)a Initialized PerImageEvaluation by evaluation parameters. Args: num_gt_classes: Number of ground truth object classes matching_iou_threshold: A ratio of area intersection to union, which is the threshold to consider whether a detection is true positive or not nms_iou_threshold: IOU threshold used in Non Maximum Suppression. nms_max_output_boxes: Number of maximum output boxes in NMS. group_of_weight: Weight of the group-of boxes. N)matching_iou_thresholdnms_iou_thresholdnms_max_output_boxesnum_gt_classesgroup_of_weight)selfrr r r rs b/var/www/html/ai-engine/env/lib/python3.11/site-packages/effdet/evaluation/per_image_evaluation.py__init__zPerImageEvaluation.__init__s2'=#!2$8!,.Nc |||||\}}}}||||||||||  \} } |||||||| } | | | fS)a Evaluates detections as being tp, fp or weighted from a single image. The evaluation is done in two stages: 1. All detections are matched to non group-of boxes; true positives are determined and detections matched to difficult boxes are ignored. 2. Detections that are determined as false positives are matched against group-of boxes and weighted if matched. Args: detected_boxes: A float numpy array of shape [N, 4], representing N regions of detected object regions. Each row is of the format [y_min, x_min, y_max, x_max] detected_scores: A float numpy array of shape [N, 1], representing the confidence scores of the detected N object instances. detected_class_labels: A integer numpy array of shape [N, 1], repreneting the class labels of the detected N object instances. gt_boxes: A float numpy array of shape [M, 4], representing M regions of object instances in ground truth gt_class_labels: An integer numpy array of shape [M, 1], representing M class labels of object instances in ground truth gt_is_difficult_list: A boolean numpy array of length M denoting whether a ground truth box is a difficult instance or not gt_is_group_of_list: A boolean numpy array of length M denoting whether a ground truth box has group-of tag detected_masks: (optional) A uint8 numpy array of shape [N, height, width]. If not None, the metrics will be computed based on masks. gt_masks: (optional) A uint8 numpy array of shape [M, height, width]. Can have empty masks, i.e. where all values are 0. Returns: scores: A list of C float numpy arrays. Each numpy array is of shape [K, 1], representing K scores detected with object class label c tp_fp_labels: A list of C boolean numpy arrays. Each numpy array is of shape [K, 1], representing K True/False positive label of object instances detected with class label c is_class_correctly_detected_in_image: a numpy integer array of shape [C, 1], indicating whether the correponding class has a least one instance being correctly detected in the image ) detected_boxesdetected_scoresdetected_class_labelsgt_boxesgt_class_labelsgt_is_difficult_listgt_is_group_of_listdetected_masksgt_masks)rrrrrrr)_remove_invalid_boxes_compute_tp_fp_compute_cor_loc) rrrrrrrrrrscores tp_fp_labels$is_class_correctly_detected_in_images r compute_object_detection_metricsz3PerImageEvaluation.compute_object_detection_metricssP  & &~H]_m n n O)> $22)+"7+!5 3) 3   04/D/D)+"7+)0E00,|%IIIrc ,||||tdt|jt}t |jD]A} ||||||||| \} } } } }|| | | || || <B|S)aCompute CorLoc score for object detection result. Args: detected_boxes: A float numpy array of shape [N, 4], representing N regions of detected object regions. Each row is of the format [y_min, x_min, y_max, x_max] detected_scores: A float numpy array of shape [N, 1], representing the confidence scores of the detected N object instances. detected_class_labels: A integer numpy array of shape [N, 1], repreneting the class labels of the detected N object instances. gt_boxes: A float numpy array of shape [M, 4], representing M regions of object instances in ground truth gt_class_labels: An integer numpy array of shape [M, 1], representing M class labels of object instances in ground truth detected_masks: (optional) A uint8 numpy array of shape [N, height, width]. If not None, the scores will be computed based on masks. gt_masks: (optional) A uint8 numpy array of shape [M, height, width]. Returns: is_class_correctly_detected_in_image: a numpy integer array of shape [C, 1], indicating whether the correponding class has a least one instance being correctly detected in the image Raises: ValueError: If detected masks is not None but groundtruth masks are None, or the other way around. NzIIf `detected_masks` is provided, then `gt_masks` should also be provided.dtype)rrrrr) ValueErrornpzerosrintrange_get_ith_class_arrays-_compute_is_class_correctly_detected_in_image)rrrrrrrrr#igt_boxes_at_ith_classgt_masks_at_ith_classdetected_boxes_at_ith_classdetected_scores_at_ith_classdetected_masks_at_ith_classs rr z#PerImageEvaluation._compute_cor_loc]s4  &8+;&8+?[]] ]02xx  s080,0,,t*++ 5 5A-1,F,F%x-$-$ * "$9 (*F ( BB#>$@2#>2 C44 1 3 343rcR|jdkr|jdkrt|}d}||d}|rstt||dt||d}t||} t || } nRt t||ddfd}t |} t|| } t| |j krdSdS)aCompute CorLoc score for a single class. Args: detected_boxes: A numpy array of shape [N, 4] representing detected box coordinates detected_scores: A 1-d numpy array of length N representing classification score gt_boxes: A numpy array of shape [M, 4] representing ground truth box coordinates detected_masks: (optional) A np.uint8 numpy array of shape [N, height, width]. If not None, the scores will be computed based on masks. gt_masks: (optional) A np.uint8 numpy array of shape [M, height, width]. Returns: is_class_correctly_detected_in_image: An integer 1 or 0 denoting whether a class is correctly detected in the image or not FNTaxisbox_data mask_datar) sizer)argmaxMaskList expand_dims iou_masklistBoxList iou_boxlistmaxr ) rrrrrr max_score_id mask_modedetected_boxlist gt_boxlistious rr.z@PerImageEvaluation._compute_is_class_correctly_detected_in_images,   " "}q  !yy99 ! !-(2F $I D'/!#|0LST!U!U"$.. 1MTU."V"V(X(X(X$"*8x!P!P!PJ&'7DDCC'.r~~n\[\[\[\_>]de~/f/f'g'g$!(!2!2J%&6 CCC66#;;$"===1qrc || td|| tdg} g} t|jD]} ||| k} ||| k}||||||| || \}}}}}||||| |||\}}| || || | fS)aLabels true/false positives of detections of an image across all classes. Args: detected_boxes: A float numpy array of shape [N, 4], representing N regions of detected object regions. Each row is of the format [y_min, x_min, y_max, x_max] detected_scores: A float numpy array of shape [N, 1], representing the confidence scores of the detected N object instances. detected_class_labels: A integer numpy array of shape [N, 1], representing the class labels of the detected N object instances. gt_boxes: A float numpy array of shape [M, 4], representing M regions of object instances in ground truth gt_class_labels: An integer numpy array of shape [M, 1], representing M class labels of object instances in ground truth gt_is_difficult_list: A boolean numpy array of length M denoting whether a ground truth box is a difficult instance or not gt_is_group_of_list: A boolean numpy array of length M denoting whether a ground truth box has group-of tag detected_masks: (optional) A np.uint8 numpy array of shape [N, height, width]. If not None, the scores will be computed based on masks. gt_masks: (optional) A np.uint8 numpy array of shape [M, height, width]. Returns: result_scores: A list of float numpy arrays. Each numpy array is of shape [K, 1], representing K scores detected with object class label c result_tp_fp_labels: A list of boolean numpy array. Each numpy array is of shape [K, 1], representing K True/False positive label of object instances detected with class label c Raises: ValueError: If detected masks is not None but groundtruth masks are None, or the other way around. Nz9Detected masks is available but groundtruth masks is not.z9Groundtruth masks is available but detected masks is not.)rrrrrrr)r(r,rr-_compute_tp_fp_for_single_classappend)rrrrrrrrrr result_scoresresult_tp_fp_labelsr/!gt_is_difficult_list_at_ith_class gt_is_group_of_list_at_ith_classr0r1r2r3r4r!r"s rrz!PerImageEvaluation._compute_tp_fpsD@  %(*:KMM M  !h&:KMM M  t*++ 5 5A$_%9: .$Oq$89 --1,F,F%x-$-$ * "$9 (*F ($(#G#G: <.%F$D:.$H$0$0 FL   ( ( (  & &| 4 4 4 4111rct||}|d|t||j|j}t||||}t||||} t ||} t t| |} | d} | } | | | | fS)aComputes overlaps and scores between detected and groudntruth masks. Args: detected_boxes: A numpy array of shape [N, 4] representing detected box coordinates detected_scores: A 1-d numpy array of length N representing classification score detected_masks: A uint8 numpy array of shape [N, height, width]. If not None, the scores will be computed based on masks. gt_boxes: A numpy array of shape [M, 4] representing ground truth box coordinates gt_masks: A uint8 numpy array of shape [M, height, width]. gt_is_group_of_list: A boolean numpy array of length M denoting whether a ground truth box has group-of tag. If a groundtruth box is group-of box, every detection matching this box is ignored. Returns: iou: A float numpy array of size [num_detected_boxes, num_gt_boxes]. If gt_non_group_of_boxlist.num_boxes() == 0 it will be None. ioa: A float numpy array of size [num_detected_boxes, num_gt_boxes]. If gt_group_of_boxlist.num_boxes() == 0 it will be None. scores: The score of the detected boxlist. num_boxes: Number of non-maximum suppressed detected boxes. r9r!) r> add_fieldnon_max_suppressionr r r@r) transpose ioa_masklist get_field num_boxes)rrrrrrrrFgt_non_group_of_boxlistgt_group_of_boxlistiou_bioa_br!rVs r"_get_overlaps_and_scores_mask_modez5PerImageEvaluation._get_overlaps_and_scores_mask_modes,$^~VVV""8_===./?AZ\`\rss"*223xI\H\?]#_#_#_&12hGZ>[]]]-/FGG \*=?OPPQQ!++H55$..00 eVY..rct|}|d|t||j|j}t||}t||}t ||}t t||} | d} | } || | | fS)a+Computes overlaps and scores between detected and groudntruth boxes. Args: detected_boxes: A numpy array of shape [N, 4] representing detected box coordinates detected_scores: A 1-d numpy array of length N representing classification score gt_boxes: A numpy array of shape [M, 4] representing ground truth box coordinates gt_is_group_of_list: A boolean numpy array of length M denoting whether a ground truth box has group-of tag. If a groundtruth box is group-of box, every detection matching this box is ignored. Returns: iou: A float numpy array of size [num_detected_boxes, num_gt_boxes]. If gt_non_group_of_boxlist.num_boxes() == 0 it will be None. ioa: A float numpy array of size [num_detected_boxes, num_gt_boxes]. If gt_group_of_boxlist.num_boxes() == 0 it will be None. scores: The score of the detected boxlist. num_boxes: Number of non-maximum suppressed detected boxes. r!) rArQrRr r rBr)rS ioa_boxlistrUrV) rrrrrrFrWrXrYrZr!rVs r!_get_overlaps_and_scores_box_modez4PerImageEvaluation._get_overlaps_and_scores_box_modes$#>22""8_===./?AZ\`\rss")(4G3G*H"I"I%h/B&CDD,.EFF [)<>NOOPP!++H55$..00 eVY..rc , |jdkrBtgttgtfSd}||d}tddg} tddg} tddg} tddg} |rt|ddk} ||||| ddf|| ddf|| \} } t | t| kr0 |||| ddf||  \} } }|j dnDt |j t} |||| \} } |jdkr#t tfSt tt tt tt tfd }fd }| j d dkr%|| }|| }|| ||d tdgt}tdgt}| j d dkr|| d \}}| j d dkr'|| }|| }|| ||d tdgt}tdgt}| j d dkr|| d \}}|rgzz}t ||ft | t|ffSz}t ||ft | t|ffS)aLabels boxes detected with the same class from the same image as tp/fp. Args: detected_boxes: A numpy array of shape [N, 4] representing detected box coordinates detected_scores: A 1-d numpy array of length N representing classification score gt_boxes: A numpy array of shape [M, 4] representing ground truth box coordinates gt_is_difficult_list: A boolean numpy array of length M denoting whether a ground truth box is a difficult instance or not. If a groundtruth box is difficult, every detection matching this box is ignored. gt_is_group_of_list: A boolean numpy array of length M denoting whether a ground truth box has group-of tag. If a groundtruth box is group-of box, every detection matching this box is ignored. detected_masks: (optional) A uint8 numpy array of shape [N, height, width]. If not None, the scores will be computed based on masks. gt_masks: (optional) A uint8 numpy array of shape [M, height, width]. Returns: Two arrays of the same size, containing all boxes that were evaluated as being true positives or false positives; if a box matched to a difficult box or to a group-of box, it is ignored. scores: A numpy array representing the detection scores. tp_fp_labels: a boolean numpy array indicating whether a detection is a true positive. r6r&FNT)rr7)rrrrrr)rrrrcvt|d}t|jdt}t D]_}||} | o$ | o|||f jko | }|r%||s||sd |<d||<||<Zd |<`dS)aComputes TP/FP for non group-of box matching. The function updates the following local variables: tp_fp_labels - if a box is matched to group-of is_matched_to_difficult - the detections that were processed at this are matched to difficult box. is_matched_to_box - the detections that were processed at this stage are marked as is_box. Args: iou_matrix: intersection-over-union matrix [num_gt_boxes]x[num_det_boxes]. gt_nongroup_of_is_difficult_list: boolean that specifies if gt box is difficult. is_box: boolean that specifies if currently boxes or masks are processed. rr7r&TN)r)r=r*shapeboolr,r ) iou_matrix gt_nongroup_of_is_difficult_listis_boxmax_overlap_gt_idsis_gt_detectedr/gt_idis_evaluatableis_matched_to_boxis_matched_to_difficultis_matched_to_group_ofnum_detected_boxesrr"s rcompute_match_iouzMPerImageEvaluation._compute_tp_fp_for_single_class..compute_match_iou{s"$:A!>!> XXj&6q&9XFFN-.. : :*1-$Q'2/222q%x(D,GG2/q11  ":;EB:-e4:.2LO48N5139-a059/2 : :rcTt|jdt}jt|jdtz}t|d}t D]c}||}| o$ | o|||fjko | }|r)d |<| |<t|| |||<dt |dk|dkz}||}||}||fS)aComputes TP/FP for group-of box matching. The function updates the following local variables: is_matched_to_group_of - if a box is matched to group-of is_matched_to_box - the detections that were processed at this stage are marked as is_box. Args: ioa_matrix: intersection-over-area matrix [num_gt_boxes]x[num_det_boxes]. is_box: boolean that specifies if currently boxes or masks are processed. Returns: scores_group_of: of detections matched to group-of boxes[num_groupof_matched]. tp_fp_labels_group_of: boolean array of size [num_groupof_matched], all values are True. rr&r7Tr6) r)r*rbfloatronesr=r,r rCwhere) ioa_matrixrfscores_group_oftp_fp_labels_group_ofmax_overlap_group_of_gt_idsr/rirjselectorrkrlrmrnr!rr"s rcompute_match_ioazMPerImageEvaluation._compute_tp_fp_for_single_class..compute_match_ioasQ!hhz'7':%hHHO$($8277:CSTUCV^c7;d;d$d !*,))JQ)*G*G '-.. T T3A6$Q'2/222q%x(D,GG2/q11  "T04*1-+1%a(-01GPQ-S-SOE*xx1!49NQR9R STTH-h7O$9($C !"$99 9rr)rf)r<r)arrayrqrcndarraysumr[lenr^rbr* concatenateastype) rrrrrrrrrErYrZiou_mioa_mmask_presence_indicator_rorygt_is_difficult_mask_listgt_is_group_of_mask_listscores_mask_group_oftp_fp_labels_mask_group_ofgt_is_difficult_box_listgt_is_group_of_box_listscores_box_group_oftp_fp_labels_box_group_of valid_entriesrkrlrmrnr!r"s ` @@@@@@rrJz2PerImageEvaluation._compute_tp_fp_for_single_class1s0  ! # #88Be8,,bhhrh.F.FF F  %(*>I Aq6"" Aq6"" Aq6"" Aq6""  9 (*vvhVv'D'Dq'H #7;7^7^- /-!"9111"<=!"9111"<=$78O$P 8_8R8R 4E5&"4*++c2I.J.JJJ6:6\6\#1$3%'>&>&AB(;=TA  (<=T(U %':;R'S $  e%>@X?X%Ybg h h h h!zz1#Uz;;%'ZZ5Z%A%A" ;q>A  ?P?PQV_d?e?e?e < "< ;q>A  ';=TV%W`d e e e e jj!Ej::$&JJs%J$@$@! ;q>A  =N=Nu]a=b=b=b : !:  j559O8OOSdRddM>>6-#8:N"OPP>>< #>#E#Ee#L#LNh"ijjk k659O8OOM>>6-#8:M"NOO>>< #>#E#Ee#L#LNg"hiij jrc ||k} || } | || } nd} ||k} || } || }| || }nd}| | | ||fS)aReturns numpy arrays belonging to class with index `class_index`. Args: detected_boxes: A numpy array containing detected boxes. detected_scores: A numpy array containing detected scores. detected_masks: A numpy array containing detected masks. detected_class_labels: A numpy array containing detected class labels. gt_boxes: A numpy array containing groundtruth boxes. gt_masks: A numpy array containing groundtruth masks. gt_class_labels: A numpy array containing groundtruth class labels. class_index: An integer index. Returns: gt_boxes_at_ith_class: A numpy array containing groundtruth boxes labeled as ith class. gt_masks_at_ith_class: A numpy array containing groundtruth masks labeled as ith class. detected_boxes_at_ith_class: A numpy array containing detected boxes corresponding to the ith class. detected_scores_at_ith_class: A numpy array containing detected scores corresponding to the ith class. detected_masks_at_ith_class: A numpy array containing detected masks corresponding to the ith class. N)rrrrrrrr class_indexselected_groundtruthr0r1selected_detectionsr2r3r4s rr-z(PerImageEvaluation._get_ith_class_arrayss(!0; > ()= >  $,-A$B ! !$( !4 C&45H&I#'67J'K$  %*89L*M ' '*. '%'<+-I+- -rct|dddf|dddfk|dddf|dddfk}||}||}||}|||}||||gS)aRemoves entries with invalid boxes. A box is invalid if either its xmax is smaller than its xmin, or its ymax is smaller than its ymin. Args: detected_boxes: A float numpy array of size [num_boxes, 4] containing box coordinates in [ymin, xmin, ymax, xmax] format. detected_scores: A float numpy array of size [num_boxes]. detected_class_labels: A int32 numpy array of size [num_boxes]. detected_masks: A uint8 numpy array of size [num_boxes, height, width]. Returns: valid_detected_boxes: A float numpy array of size [num_valid_boxes, 4] containing box coordinates in [ymin, xmin, ymax, xmax] format. valid_detected_scores: A float numpy array of size [num_valid_boxes]. valid_detected_class_labels: A int32 numpy array of size [num_valid_boxes]. valid_detected_masks: A uint8 numpy array of size [num_valid_boxes, height, width]. Nr6r`r)r) logical_and)rrrrr valid_indicess rrz(PerImageEvaluation._remove_invalid_boxess" 111a4 >!!!Q$#7 719MP^_`_`_`bc_cPd9dff ' 6)-8 5m D  %+M:N1FWWr)rrrr )NN)N)__name__ __module__ __qualname____doc__rr$r r.rr[r^rJr-rrrrrrs"66),#&&(!$ ////0+/>J>J>J>JDFJ04040404f\`    Hqu>2>2>2>2@!/!/!/F///>VZhjhjhjhjT#-#-#-LZ^XXXXXXrrN) np_mask_listmetricsrrrrrscSXSXSXSXSXSXSXSXSXSXr