hIddlZddlZddlmZddlmcmZGddejZ GddejZ GddejZ dZ d Z d Zy) Nc&eZdZdfd ZdZxZS) BlazeBlockc vtt| ||_||z |_|dk(rt j |||_d}n|dz dz}t jt j||||||dt j||dddd|_ t jd|_ y) N) kernel_sizestriderT in_channels out_channelsrrpaddinggroupsbiasr r rrr rinplace) superr__init__r channel_padnn MaxPool2dmax_pool SequentialConv2dconvsReLUact)selfr r rrr __class__s j/var/www/html/engine/venv/lib/python3.12/site-packages/face_alignment/detection/blazeface/net_blazeface.pyrzBlazeBlock.__init__s j$(* '+5 Q;LLVFKDMG"Q1,G]] II+K"-fg(t 5 II+L"#Aqt E   774(c ,|jdk(r*tj|ddd}|j|}n|}|jdkDr(tj|ddddd|jfdd}|j |j ||zS)Nrrrrrconstantr)rFpadrrrrrxhs r forwardzBlazeBlock.forward s ;;! az15A a AA   a a!Q1a)9)9:JJAxx 1 )**r!)r __name__ __module__ __qualname__rr* __classcell__rs@r rrs )0 +r!rc&eZdZdfd ZdZxZS)FinalBlazeBlockc tt| tjtj |||dd|dtj ||dddd|_tjd|_y)NrrTr r rr) rr3rrrrrrr)rchannelsrrs r rzFinalBlazeBlock.__init__-sl ot-/]] II("-a%D 2 II("#Aqt E   774(r!crtj|ddd}|j|j|S)Nr#r$r)r%r&rrr's r r*zFinalBlazeBlock.forward;s- EE!\:q 1xx 1 &&r!)r+r,r1s@r r3r3,s  )'r!r3c|eZdZdZdfd ZdZdZdZdZdZ dZ dd Z dd Z d Z d Zd ZdZdZdZxZS) BlazeFaceaThe BlazeFace face detection model from MediaPipe. The version from MediaPipe is simpler than the one in the paper; it does not use the "double" BlazeBlocks. Because we won't be training this model, it doesn't need to have batchnorm layers. These have already been "folded" into the conv weights by TFLite. The conversion to PyTorch is fairly straightforward, but there are some small differences between TFLite and PyTorch in how they handle padding on conv layers with stride 2. This version works on batches, while the MediaPipe version can only handle a single image at a time. Based on code from https://github.com/tkat0/PyTorch_BlazeFace/ and https://github.com/google/mediapipe/ c0tt| d|_d|_d|_d|_||_|r$d|_d|_ d|_ d|_ d|_ n#d|_d|_ d|_ d|_ d|_ d |_ |jy) Nr igY@gp@g?g`@g?g333333?)rr8r num_classes num_anchors num_coordsscore_clipping_thresh back_modelx_scaley_scaleh_scalew_scalemin_score_threshmin_suppression_threshold_define_layers)rr?rs r rzBlazeFace.__init__Vs i') %*"$  DL DL DL DL$(D ! DL DL DL DL$(D !),& r!c 6tjtjddddddtjdgt d Dcgc]}t ddc}t ddd t d Dcgc]}t ddc}t dd d t d Dcgc]}t d d c}t d d d t d Dcgc]}t d d c}|_td |_tjd dd d|_ tjd dd d|_ tjd dd d|_ tjd d d d|_ ycc}wcc}wcc}wcc}w)Nr+rrTrrr0`r r ) rrrrrangerbackboner3final classifier_8 classifier_16 regressor_8 regressor_16)r_s r _define_back_model_layersz#BlazeFace._define_back_model_layersqsg II!"!AWX_c d GGD !  +0( 3QjR 3   r2a (  +0( 3QjR 3  r2a (  +0( 3QjR 3   r2a (  +0( 3QjR 3   %R( IIb!QT:YYr1ad;99RQT:IIb"ad;4 3 3 3s F >F /F F c"tjtjddddddtjdt ddt dd t d d d t d d t d d t d dd t ddt ddt ddt ddt dd |_tjt ddd t ddt ddt ddt dd|_tjdddd|_tjdddd|_tjdd dd|_ tjdddd|_ y)Nr+rHrIrrTrrrPrK$*rL8@HPXrMr rNrO) rrrrr backbone1 backbone2rTrUrVrWrs r _define_front_model_layersz$BlazeFace._define_front_model_layerssM II!"! 6 GGD ! r2  r2  r2a ( r2  r2  r2a ( r2  r2  r2  r2  r2  $ r2a ( r2  r2  r2  r2   IIb!QT:YYr1ad;99RQT:IIb"ad;r!c^|jr|jy|jyN)r?rYrfres r rFzBlazeFace._define_layerss! ??  * * ,  + + -r!ctj|ddd}|jd}|jr#|j |}|j |}n"|j |}|j|}|j|}|jdddd}|j|dd}|j|}|jdddd}|j|dd}tj||fd}|j|}|jdddd}|j|dd }|j|}|jdddd}|j|dd }tj||fd} | |gS) N)r rr rr$rrr+r dimr:)r%r&shaper?rRrSrcrdrTpermutereshaperUtorchcatrVrW) rr(br)c1c2cr1r2rs r r*zBlazeFace.forwardsn EE!\:q 1 GGAJ ?? a A 1 Aq!Aq!A   q ! ZZ1a # ZZ2q !    " ZZ1a # ZZ2q ! IIr2hA &   a  ZZ1a # ZZ2r "   q ! ZZ1a # ZZ2r " IIr2hA &1v r!cB|jjjS)z6Which device (CPU or GPU) is being used by this model?)rTweightdeviceres r _devicezBlazeFace._devices  ''...r!cl|jtj||jyrh)load_state_dictrploadeval)rpaths r load_weightszBlazeFace.load_weightss" UZZ-. r!cr|xs|j}tjtj|tj ||_|j jdk(sJ|j jd|jk(sJ|j jddk(sJyN)dtyper{rrr ) r|rptensornprfloat32anchors ndimensionrmr<)rrr{s r load_anchorszBlazeFace.load_anchorss)4<<>|| GGDMv? ||&&(A-.-||!!!$(8(8898||!!!$)*)r!cL|xs|j}tj|tj||_|jj dk(sJ|jj d|jk(sJ|jj ddk(sJyr)r|rprrrrrmr<)rarrr{s r load_anchors_from_npyzBlazeFace.load_anchors_from_npys)4<<>|| u}}V5 ||&&(A-.-||!!!$(8(8898||!!!$)*)r!c.|jdz dz S)z/Converts the image pixels to the range [-1, 1].g_@g?)float)rr(s r _preprocesszBlazeFace._preprocessswwy5 3&&r!ct|tjr$tj|j d}|j |jddS)a.Makes a prediction on a single image. Arguments: img: a NumPy array of shape (H, W, 3) or a PyTorch tensor of shape (3, H, W). The image's height and width should be 128 pixels. Returns: A tensor with face detections. )rrr r) isinstancerndarrayrp from_numpyrnpredict_on_batch unsqueeze)rimgs r predict_on_imagezBlazeFace.predict_on_imagesL c2:: &""3'// :C$$S]]1%56q99r!clt|tjr$tj|j d}|j ddk(sJ|jr(|j ddk(sJ|j ddk(s*J|j ddk(sJ|j ddk(sJ|j|j}|j|}tj5|j|}ddd|jd|d|j}g}tt!|D]_}|j#||}t!|dkDrtj$|ntj&d }|j)|a|S#1swYxYw) afMakes a prediction on a batch of images. Arguments: x: a NumPy array of shape (b, H, W, 3) or a PyTorch tensor of shape (b, 3, H, W). The height and width should be 128 pixels. Returns: A list containing a tensor of face detections for each image in the batch. If no faces are found for an image, returns a tensor of shape (0, 17). Each face detection is a PyTorch tensor consisting of 17 numbers: - ymin, xmin, ymax, xmax - x,y-coordinates for the 6 keypoints - confidence score )rr+r rr r+rNr)r)rrrrprrnrmr?tor|rinference_mode__call___tensors_to_detectionsrrQlen_weighted_non_max_suppressionstackzerosappend)rr(out detectionsfiltered_detectionsifacess r rzBlazeFace.predict_on_batchs" a $  #++L9AwwqzQ ??771:$ $$771:$ $$771:$ $$771:$ $$ DD    Q  ! ! # #--"C #00QQN !s:' .A66z!}EE*-++EKK& % G 4   & &u -  . #" # #s 3F**F3c@|jdk(sJ|jd|jk(sJ|jd|jk(sJ|jdk(sJ|jd|jk(sJ|jd|jk(sJ|jd|jdk(sJ|j ||}|j }|j| |}|jjd}||jk\}g}t|jdD]]} || || f} || || fjd} |jtj| | fdj!d_|S)a`The output of the neural network is a tensor of shape (b, 896, 16) containing the bounding box regressor predictions, as well as a tensor of shape (b, 896, 1) with the classification confidences. This function converts these two "raw" tensors into proper detections. Returns a list of (num_detections, 17) tensors, one for each image in the batch. This is based on the source code from: mediapipe/calculators/tflite/tflite_tensors_to_detections_calculator.cc mediapipe/calculators/tflite/tflite_tensors_to_detections_calculator.proto r+r rrrjrkcpu)rrmr<r=r; _decode_boxesr>clampsigmoidsqueezerDrQrrrprqr) rraw_box_tensorraw_score_tensorrdetection_boxesthreshdetection_scoresmaskoutput_detectionsrboxesscoress r rz BlazeFace._tensors_to_detections/s((*a///##A&$*:*::::##A&$//999**,111%%a(D,<,<<<<%%a(D,<,<<<<##A&*:*@*@*CCCC,,^WE+++116'6B+335=="=E  4#8#88~++A./ SA#AtAwJ/E%aaj1;;;CF  $ $UYYvB%G%J%J5%Q R S ! r!ctj|}|d|jz |dddfz|dddfz}|d|jz |dddfz|dddfz}|d|jz |dddfz}|d |j z |dddfz}||d z z |d<||d z z |d<||d z z|d<||d z z|d <t d D]n}d |dzz} |d | f|jz |dddfz|dddfz} |d | dzf|jz |dddfz|dddfz} | |d | f<| |d | dzf<p|S)z}Converts the predictions into actual coordinates using the anchor boxes. Processes the entire batch at once. ).rNrr).r r+r ).r).r+g@rOr.)rp zeros_liker@rArCrBrQ) r raw_boxesrrx_centery_centerwr)koffset keypoint_x keypoint_ys r rzBlazeFace._decode_boxes[s  +V$t||3 AqDM#AqDM*V$t||3 AqDM#AqDM* f  ,wq!t} < f  ,wq!t} < 1r6)f  1r6)f  1r6)f  1r6)f q 0AQYF"3;/ &q!t}-/6q!t}=J"3 ?3 &q!t}-/6q!t}=J!+E#v+ %/E#vz/ " 0 r!ct|dk(rgSg}tj|dddfd}t|dkDr||d}|dd}||ddf}t||}||jkD}||} ||}|j } t| dkDrP|| ddf} || ddf} | j } | | zj d | z }|| dd| t| z | d<|j| t|dkDr|S) aThe alternative NMS method as mentioned in the BlazeFace paper: "We replace the suppression algorithm with a blending strategy that estimates the regression parameters of a bounding box as a weighted mean between the overlapping predictions." The original MediaPipe code assigns the score of the most confident detection to the weighted detection, but we take the average score of the overlapping detections. The input detections should be a Tensor of shape (count, 17). Returns a list of PyTorch tensors, one for each detected face. This is based on the source code from: mediapipe/calculators/util/non_max_suppression_calculator.cc mediapipe/calculators/util/non_max_suppression_calculator.proto rNr:T) descendingrr rrk)rrpargsortoverlap_similarityrEclonesumr)rrr remaining detection first_box other_boxesiousr overlappingweighted_detection coordinatesr total_scoreweighteds r rz'BlazeFace._weighted_non_max_suppressionysS& z?a IMM*QU"3E )nq "9Q<0I ""1 I$Y]3K%i=D$888D#D/K!4%(I"+!2 ;!#(crc)9: #KB$67$jjl '&055!5<{J*2"3B')4s;7G)G"2&  $ $%7 87)nq :! r!)Frh)r-r.r/__doc__rrYrfrFr*r|rrrrrrrrrr0r1s@r r8r8AsW(6<& [A,1,2] -> [A,B,2] [B,2] -> [1,B,2] -> [A,B,2] Then we compute the area of intersect between box_a and box_b. Args: box_a: (tensor) bounding boxes, Shape: [A,4]. box_b: (tensor) bounding boxes, Shape: [B,4]. Return: (tensor) intersection area, Shape: [A,B]. rNrr )min)sizerprrexpandmaxr)box_abox_bABmax_xymin_xyinters r intersectrs   1 A 1 A YYuQU|--a0771a@QU|--a0771a@BF YYuQU|--a0771a@QU|--a0771a@BF KK&q 1E Aq>E!Q'N **r!cHt||}|dddf|dddfz |dddf|dddfz zjdj|}|dddf|dddfz |dddf|dddfz zjdj|}||z|z }||z S)u Compute the jaccard overlap of two sets of boxes. The jaccard overlap is simply the intersection over union of two boxes. Here we operate on ground truth boxes and default boxes. E.g.: A ∩ B / A ∪ B = A ∩ B / (area(A) + area(B) - A ∩ B) Args: box_a: (tensor) Ground truth bounding boxes, Shape: [num_objects,4] box_b: (tensor) Prior boxes from priorbox layers, Shape: [num_priors,4] Return: jaccard overlap: (tensor) Shape: [box_a.size(0), box_b.size(0)] Nrrr+r )rr expand_as)rrrarea_aarea_bunions r jaccardrs eU #EQT{U1a4[(q!tuQT{*,-6Yq\))E:J QT{U1a4[(q!tuQT{*,-6Yq\))E:J VOe #E 5=r!cVt|jd|jdS)z?Computes the IOU between a bounding box and set of other boxes.r)rrr)boxrs r rrs# 3==#[ 1 9 9! <rsW #+#+J'bii'*p! p!j +**=r!