Ng)dZddlZddlmZddlmcmZddlmZm Z m Z de de fdZ d$de de de fd Z d%d e d eejdefdZ d&de d eejdefdZd'd e fdZdefdZ d(de ejde ejde ejde ejdejdede de d e de de ded e ejejejffd!ZejeZGd"d#ejZdS))z EfficientDet Focal, Huber/Smooth L1 loss fns w/ jit support Based on loss fn in Google's automl EfficientDet repository (Apache 2.0 license). https://github.com/google/automl/tree/master/efficientdet Copyright 2020 Ross Wightman N)OptionalListTuplealphagammac P|dk}tj|||jd}d|z}t j||z|z|t jt j|zz }||z} t j||| zd|z | z} | |z S)aCompute the focal loss between `logits` and the golden `target` values. 'Legacy focal loss matches the loss used in the official Tensorflow impl for initial model releases and some time after that. It eventually transitioned to the 'New' loss defined below. Focal loss = -(1-pt)^gamma * log(pt) where pt is the probability of being classified to the true class. Args: logits: A float32 tensor of size [batch, height_in, width_in, num_predictions]. targets: A float32 tensor of size [batch, height_in, width_in, num_predictions]. alpha: A float32 scalar multiplying alpha to the loss from positive examples and (1-alpha) to the loss from negative examples. gamma: A float32 scalar modulating loss from hard and easy examples. normalizer: A float32 scalar normalizes the total loss from all examples. Returns: loss: A float32 scalar representing normalized total loss. ?none reductiong)F binary_cross_entropy_with_logitstodtypetorchexplog1pwhere) logitstargetsrr normalizerpositive_label_mask cross_entropy neg_logits modulatorloss weighted_losss G/var/www/html/ai-engine/env/lib/python3.11/site-packages/effdet/loss.pyfocal_loss_legacyrs2"S.6vwzz&,?W?WcijjjMJ %'/J6UYWaMbMbAcAc9ccddI } $DK 3UT\C%KSWCWXXM : %%{Gz?label_smoothingc"|}||j}d|z }||z|d|z zz}||z|d|z zz} d|z |z} |dkr|d|z zd|zz}tj||d} d|z | z| z| zS)a$Compute the focal loss between `logits` and the golden `target` values. 'New' is not the best descriptor, but this focal loss impl matches recent versions of the official Tensorflow impl of EfficientDet. It has support for label smoothing, however it is a bit slower, doesn't jit optimize well, and uses more memory. Focal loss = -(1-pt)^gamma * log(pt) where pt is the probability of being classified to the true class. Args: logits: A float32 tensor of size [batch, height_in, width_in, num_predictions]. targets: A float32 tensor of size [batch, height_in, width_in, num_predictions]. alpha: A float32 scalar multiplying alpha to the loss from positive examples and (1-alpha) to the loss from negative examples. gamma: A float32 scalar modulating loss from hard and easy examples. normalizer: Divide loss by this value. label_smoothing: Float in [0, 1]. If > `0` then smooth the labels. Returns: loss: A float32 scalar representing normalized total loss. r ?r r )sigmoidrrr r) rrrrrr" pred_prob onem_targetsp_t alpha_factormodulating_factorces rnew_focal_lossr.2s*  Ijj&&G#B CCU?\R%Z%@@Lce+R/12R/5II +FGv N N NB  Nl *-> > CCr r Tdeltaweights size_averagec(||z }|}tj||}||z }d|dz||zz} || |} |r| S| S)z )maxr%)absrclamppowmulmeansum) inputtargetr/r0r1errabs_err quadraticlinearrs r huber_lossrAWs &.CggiiG G///I y F q!! !EFN 2Dxx  yy{{xxzzr qq?betac@|dkrtj||z }nPtj||z }tj||kd|dz|z |d|zz }|||z}|r|S|S)z\ very similar to the smooth_l1_loss from pytorch, but with the extra beta parameter gh㈵>r%r4)rr5rr7r9r:)r;r<rCr0r1rr=s rsmooth_l1_lossrEhs  d{{ y((i''{3:sSWWQZZ'7$'>cDj@PQQ yy{{xxzzr 皙?cJ|dz}|dk}t||||d}||z S)zComputes box regression loss.g@r$F)r0r/r1)rA) box_outputs box_targets num_positivesr/rmaskbox_losss r _box_lossrMs< $J # D+{D\abbbH j  r num_classesc|dkd}tj|j|fz|jtj}|d|d|zd|zS)Nr)devicerr&) unsqueezerzerosshaperQfloat32scatter)xrN x_non_negonehots rone_hotrZsfa""2&&I [K>1!(%- X X XF >>"akk"oo 91 = = IIr r$F cls_outputsrH cls_targetsrIrJbox_loss_weight legacy_focalreturnc |dz} t|} g}g}t| D]T}||}||}t ||}|j\}}}}}||||d}||dddd}| rt||||| }nt||||| | }||||d|}||d k dz}| || t||dddd|| | Vtjtj|d d }tjtj|d d }|| |zz}|||fS) aaComputes total detection loss. Computes total detection loss including box and class loss from all levels. Args: cls_outputs: a List with values representing logits in [batch_size, height, width, num_anchors]. at each feature level (index) box_outputs: a List with values representing box regression targets in [batch_size, height, width, num_anchors * 4] at each feature level (index) cls_targets: groundtruth class targets. box_targets: groundtrusth box targets. num_positives: num positive grountruth anchors Returns: total_loss: an integer tensor representing total loss reducing from class and box losses from all levels. cls_loss: an integer tensor representing total class loss. box_loss: an integer tensor representing total box regression loss. r rPrr4r&)rrr)rrrr")r/)dim)r:floatlenrangerZrTviewpermuterr.rRappendrMrstack)r[rHr\rIrJrNrrr/r]r"r^num_positives_sumlevels cls_losses box_losseslcls_targets_at_levelbox_targets_at_levelcls_targets_at_level_ohbsheightwidth_cls_outputs_at_levelcls_lossrL total_losss rloss_fnrzsDL'**,,s299;;   FJJ 6]]*1~*1~#**> "L"L"9"?FE1a"9">">r65RT"U"U*1~55aAqAAGGII  i($&=55FHHHHH&$&=55FXgiiiH==VUB DD3r9DDRHHH(,,..)))) N " "1aA . . 4 4 6 6      yZR888bAAAHyZR888bAAAHOh66J x ))r ceZdZdgZfdZdeejdeejdeejdeejdejdeejejejff d Z xZ S) DetectionLossrNc$tt|||_|j|_|j|_|j|_|j|_|j|_|j |_ |j |_ |j |_ dS)N) superr|__init__configrNrrr/r]r"r^jit_lossuse_jit)selfr __class__s rrzDetectionLoss.__init__sz mT""++--- !-\ \ \ %5%5"/ r r[rHr\rIrJr_ct}tjs|jrt }|||||||j|j|j|j |j |j |j  S)N)rNrrr/r]r"r^) rzrjit is_scriptingrloss_jitrNrrr/r]r"r^)rr[rHr\rIrJl_fns rforwardzDetectionLoss.forwards|y%%'' DL Dt k; ( $*TXT^ 0$BVeievxxx xr ) __name__ __module__ __qualname__ __constants__rrrTensorrr __classcell__)rs@rr|r|s"OM ' ' ' ' 'xel+xel+xel+ x el+ x !< x -2%, el2Z,[ xxxxxxxxr r|)r!)r NT)rBNT)rF)r$F)__doc__rtorch.nnnntorch.nn.functional functionalr typingrrrrdrr.rboolrArErMintrZrzrscriptrModuler|r rrs (((((((((( &e &E & & & &F"D"D5"D"D]b"D"D"D"DLhl#3;EL3I`d$ko"6>u|6Lcg.!!e!!!!JCJJJJ$"$"K*K*%,'K*%,'K*%,'K*%,' K* | K*  K*K*K*K*K*K*K*5<u|; <K*K*K*K*\ 9  G $ $!x!x!x!x!xBI!x!x!x!x!xr