:jddlZddlZddlmZddlmZddlmZmZm Z ddl Z ddl m Z m Z ddl mZmZmZddlmZdd lmZdd lmZd d lmZmZmZd d lmZd dlm Z m!Z!d dl"m#Z#m$Z$ddl%mZ&ddlm'Z'm(Z(ddl)m*Z*ddl+m,Z,m-Z-ddl.m/Z/gdZ0de1e de fdZ2dZ3dZ4Gdde jjZ6Gdde jjZ7Gd d!e jjZ8Gd"d#e jjZ9ed$d%Z:Gd&d'eZ;Gd(d)eZ<ee!d*e;jzfd+e$j|f,dd-de$j|dd.d/e e;d0e?d1e e@d2e e$d3e e@d4ede9fd5ZAee!d*e& >DacU!D62GaSD62G*$&0nnW&= 7#  >>r/c^tddD}dt|z}t||}|S)Nc3VK|]!}|t|dzt|dzf#yw)gr(?gz%_default_anchorgen..3s,pST!S^!34c!n:L6MNps')) @i))??g@)tuplelenr) anchor_sizes aspect_ratiosanchor_generators r-_default_anchorgenrM2s5pXoppL&\)::M&|]C r/cZeZdZdZddeedejfffd ZdZ dZ xZ S) RetinaNetHeadau A regression and classification head for use in RetinaNet. Args: in_channels (int): number of channels of the input feature num_anchors (int): number of anchors to be predicted num_classes (int): number of classes to be predicted norm_layer (callable, optional): Module specifying the normalization layer to use. Default: None norm_layer.cpt|t|||||_t ||||_y)NrP)super__init__RetinaNetClassificationHeadclassification_headRetinaNetRegressionHeadregression_head)self in_channels num_anchors num_classesrP __class__s r-rTzRetinaNetHead.__init__Ds8 #> kj$   7{K\fgr/cz|jj||||jj||||dS)N)classificationbbox_regression)rV compute_lossrX)rYtargets head_outputsanchors matched_idxss r-razRetinaNetHead.compute_lossKsC#66CCG\[gh#33@@,X_amn  r/cH|j||j|dS)N) cls_logitsr`)rVrX)rYr's r-forwardzRetinaNetHead.forwardRs$"66q9dNbNbcdNeffr/N) __name__ __module__ __qualname____doc__rrrModulerTrarh __classcell__r]s@r-rOrO9s9h(S[\_acajaj\jSkJlh gr/rOcleZdZdZdZ d deedejfffd Z fdZ dZ dZ xZ S) rUaf A classification head for use in RetinaNet. Args: in_channels (int): number of channels of the input feature num_anchors (int): number of anchors to be predicted num_classes (int): number of classes to be predicted norm_layer (callable, optional): Module specifying the normalization layer to use. Default: None rrP.ct |g}tdD])}|jt j |||+t j||_|jjD]}t|t jstj jj|jd|j `tj jj#|j dt j|||zddd|_tj jj|j$jdtj jj#|j$j t'j(d|z |z  ||_||_t.j0j2|_y) Nr1rR{Gz?stdrr r kernel_sizestridepadding)rSrTr5append misc_nn_opsConv2dNormActivationr Sequentialconvmodules isinstanceConv2dtorchinitnormal_r2r3 constant_rgmathlogr\r[ det_utilsMatcherBETWEEN_THRESHOLDS) rYrZr[r\prior_probabilityrPr~_layerr]s r-rTz$RetinaNetClassificationHead.__init__dsl q kA KK 88k^hi j kMM4( YY&&( ;E%+ %%ell%=::)HHMM++EJJ:  ; ))K{1JXYbcmno  doo44$?   4 4txxEVAVZk@k7l6lm&& #,"3"3"F"Fr/c z|jdd}||dkr t||t | |||||||yNversionrgetr<rS_load_from_state_dict rYr7r8local_metadatastrict missing_keysunexpected_keys error_msgsrr]s r-rz1RetinaNetClassificationHead._load_from_state_dictN!$$Y5 ?gk j& 1 %        r/c\g}|d}t|||D]\}}}|dk\} | j} tj|} d| | |d|| f<||jk7} |j t || | | dtd| z t|t|z S)NrgrrGlabelssum) reductionr) ziprr zeros_likerrzr maxr.rI) rYrbrcrelossesrgtargets_per_imagecls_logits_per_imagematched_idxs_per_imageforeground_idxs_per_imagenum_foregroundgt_classes_targetvalid_idxs_per_images r-raz(RetinaNetClassificationHead.compute_losss!,/ ORSZ\fhtOu  K 35K(>!(C %6::%&:;# a( ) ! 2F|c'l**r/clg}|D]}|j|}|j|}|j\}}}}|j|d|j||}|j ddddd}|j |d|j}|j|tj|dS)Nrr r1rrdim) r~rgshapeviewr\permutereshaperzrcat) rYr'all_cls_logitsfeaturesrgNrHWs r-rhz#RetinaNetClassificationHead.forwards .H8,J4J$))JAq!Q#B0@0@!QGJ#++Aq!Q:J#++Ar43C3CDJ  ! !* - .yyQ//r/)rsN)rjrkrlrm_versionrrrrnrTrrarhrorps@r-rUrUWsKH9= G Xc299n56 GB 2+B0r/rUceZdZdZdZdej iZd dee de jfffd Z fdZ dZd ZxZS) rWa% A regression head for use in RetinaNet. Args: in_channels (int): number of channels of the input feature num_anchors (int): number of anchors to be predicted norm_layer (callable, optional): Module specifying the normalization layer to use. Default: None r box_coderrP.ct|g}tdD])}|jt j |||+t j||_t j||dzddd|_ tj jj|jjdtj jj|jj |jj#D]}t%|t jstj jj|jd|j `tj jj|j t'j(d |_d |_y) Nr1rRr rrvrsrtrGrGrGrGweightsl1)rSrTr5rzr{r|rr}r~rbbox_regrrrr2zeros_r3rrrBoxCoderr _loss_type)rYrZr[rPr~rrr]s r-rTz RetinaNetRegressionHead.__init__s@ q kA KK 88k^hi j kMM4(  +{QAVWabc   dmm22=  T]]//0YY&&( 5E%+ %%ell%=::)HHMM((4  5 #++4HIr/c z|jdd}||dkr t||t | |||||||yrrrs r-rz-RetinaNetRegressionHead._load_from_state_dictrr/c g}|d}t||||D]\}}} } tj| dk\d} | j} |d| | } || ddf}| | ddf} |j t |j |j| | |td| z t|tdt|z S)Nr`rr r) rrwherenumelrzrrrrr.rI)rYrbrcrdrerr`rbbox_regression_per_imageanchors_per_imagerrrmatched_gt_boxes_per_images r-raz$RetinaNetRegressionHead.compute_losss&'89gj _g|h   c 8:KMc). 4Ja4O(PQR(S %6<<>N*;7)CDZ[tDu)v &(AB[]^B^(_ % 12KQ2N O  MMOONN%.- a()  0F|c!S\222r/cDg}|D]}|j|}|j|}|j\}}}}|j|dd||}|j ddddd}|j |dd}|j |tj|dS)Nrr1rr rrr) r~rrrrrrzrr) rYr'all_bbox_regressionrr`rrrrs r-rhzRetinaNetRegressionHead.forward0s  8H"ii1O"mmO>> import torch >>> import torchvision >>> from torchvision.models.detection import RetinaNet >>> from torchvision.models.detection.anchor_utils import AnchorGenerator >>> # load a pre-trained model for classification and return >>> # only the features >>> backbone = torchvision.models.mobilenet_v2(weights=MobileNet_V2_Weights.DEFAULT).features >>> # RetinaNet needs to know the number of >>> # output channels in a backbone. For mobilenet_v2, it's 1280, >>> # so we need to add it here >>> backbone.out_channels = 1280 >>> >>> # let's make the network generate 5 x 3 anchors per spatial >>> # location, with 5 different sizes and 3 different aspect >>> # ratios. We have a Tuple[Tuple[int]] because each feature >>> # map could potentially have different sizes and >>> # aspect ratios >>> anchor_generator = AnchorGenerator( >>> sizes=((32, 64, 128, 256, 512),), >>> aspect_ratios=((0.5, 1.0, 2.0),) >>> ) >>> >>> # put the pieces together inside a RetinaNet model >>> model = RetinaNet(backbone, >>> num_classes=2, >>> anchor_generator=anchor_generator) >>> model.eval() >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)] >>> predictions = model(x) )rproposal_matcherc ^t|t|t|ds t d||_t |ttdfstdt|| t}||_ |(t|j|jd|}||_| t!j"| |d} | |_t!j&d|_|gd }|gd }t+||||fi||_| |_| |_| |_||_d |_y) N out_channelszbackbone should contain an attribute out_channels specifying the number of output channels (assumed to be the same for all the levels)zFanchor_generator should be of type AnchorGenerator or None instead of rT)allow_low_quality_matchesrr)g ףp= ?gv/?gCl?)gZd;O?gy&1?g?F)rSrTrhasattr ValueErrorbackbonerrr9 TypeErrorrMrLrOrnum_anchors_per_locationheadrrrrrr! transform score_thresh nms_threshdetections_per_imgtopk_candidates _has_warned)rYrr\min_sizemax_size image_mean image_stdrLrrrrr fg_iou_thresh bg_iou_threshrkwargsr]s r-rTzRetinaNet.__init__sO* D!x0+  ! *_d4j,IJXY]^nYoXpq   #13  0 < !6!68H8a8a8cde8fhstD  #(00*.   !1"++4HI  .J  -I1(HjR[f_ef($"4.!r/c"|jr|S|Sri)training)rYr detectionss r- eager_outputszRetinaNet.eager_outputss ==Mr/c g}t||D]\}}|djdk(rQ|jtj|j dfdtj |jmtj|d|}|j|j||jj||||S)Nr rr)dtypedevice) rrrzrfullsizeint64rbox_opsbox_iourrra)rYrbrcrdrerrmatch_quality_matrixs r-razRetinaNet.compute_losss 474I M 0 0 )//1Q6##JJ 1 6 6q 9;Ru{{[l[s[st#*??3DW3MO`#a    5 56J K L Myy%%g|WlSSr/cl|d}|d}t|}g}t|D]}|D cgc]} | | } } |D cgc]} | | } } ||||}} g}g}g}t| | | D]'\}}}|jd}t j |j }||jkD}||}t j|d}tj||jd}|j|\}}||}t j||d}||z}|jj||||}t!j"||}|j%||j%||j%|*t j&|d}t j&|d}t j&|d}t!j(||||j*}|d|j,}|j%||||||d|Scc} wcc} w) Nrgr`rrfloor) rounding_moder)r scoresr)rIr5rrrsigmoidflattenrrr _topk_minrtopkdivr decode_singlerclip_boxes_to_imagerzr batched_nmsrr)rYrcrd image_shapes class_logitsbox_regression num_imagesrindexbrbox_regression_per_imagecllogits_per_imager image_shape image_boxes image_scores image_labelsbox_regression_per_levellogits_per_levelanchors_per_levelr\scores_per_level keep_idxs topk_idxsnum_topkidxs anchor_idxslabels_per_levelboxes_per_levelkeeps r-postprocess_detectionsz RetinaNet.postprocess_detectionsso#L1 %&78& .0 :&3 E !KK 215 %..y$:N:NPQR)9)>)>x)H& $%dO #ii ;gV #,{#: "&..">">,[9;L[;Y##*"="=o{"[""?3##$45##$455 68 ))KQ7K 99\q9L 99\q9L&&{L,PTP_P_`D1$112D   (.*40*40 [3 ji(LAs H, H1c |jr|tjddnz|D]u}|d}tjt|tjdtjt |j dk(xr|j ddk(d wg}|D]\}|j d d}tjt |dk(d |j d d|j|d |d f^|j||\}}|t|D]\}}|d}|ddddf|ddddfk} | js3tj| jd d d } || j} tjdd| d|d|j|j} t| tjrtd| fg} t!| j#} |j%| } |j'|| }i}g}|jr.|tjddn|j)|| |}n| Dcgc]%}|j+d|j+dz'}}d }|D]}||z } | dj+d }||z}|Dcgc]}||z }}i}| D]$}t!| |j-|d ||<&|Dcgc]}t!|j-|}}|j/|||j0}|jj3||j0|}tj4j7r,|j8st;j<dd|_||fS|j?||Scc}wcc}wcc}w)a Args: images (list[Tensor]): images to be processed targets (list[Dict[Tensor]]): ground-truth boxes present in the image (optional) Returns: result (list[BoxList] or dict[Tensor]): the output from the model. During training, it returns a dict[Tensor] which contains the losses. During testing, it returns list[BoxList] contains additional fields like `scores`, `labels` and `mask` (for Mask R-CNN models). NFz0targets should not be none when in training moder z+Expected target boxes to be of type Tensor.rrr1z5Expected target boxes to be a tensor of shape [N, 4].zJexpecting the last two dimensions of the Tensor to be H and W instead got rrrzLAll bounding boxes should have positive height and width. Found invalid box z for target at index r40r rgzBRetinaNet always returns a (Losses, Detections) tuple in scriptingT) rr_assertrr rIrrzr enumerateanyrtolistrtensorsrlistvaluesrrLrarsplitr image_sizes postprocessjit is_scriptingrwarningswarnr)rYimagesrbtargetr original_image_sizesimgval target_idxdegenerate_boxesbb_idxdegen_bbrrcrdrrr'num_anchors_per_levelHWvHWAAhwsplit_head_outputska split_anchorss r-rhzRetinaNet.forward=s == e%WX%F"7OEMM*UELL"ACpqMMEKK(A-F%++b/Q2FO79 :C))BC.C MMCA \]`]f]fgigj]k\lm  ! ' 'QQ(8 9  :..9  &/&8 " Fw#(AB<5BQB<#? #'')"[[)9)=)=!)=)DEaHKF,1&M,@,@,BHMM..6Z7LZLXY[ ==0 h -"S(O#45H)*yy* ''9.0 == e%WX**7L'JEM$MqQVVAY%:$M !$MB* a |,11!4Cr A6K$LR!V$L !$L;= ! b(,\!_-B-BCX^_-B-`(a"1% bKRSaT!''*?"@ASMS445GX^XjXjkJ33J@R@RThiJ 99 ! ! ### bc#' :% %!!&*55/%N %M Ts6*O  O !O) i i5NNNNNg?rFi,rFg?iri)rjrkrlrmrrrrrTrr&unusedrrarrhrorps@r-r"r"CsVr''%--O %C!J YY T>@f6r/r")rr) categoriesrc DeZdZedeiedddddiiddd d  ZeZy ) r#zLhttps://download.pytorch.org/models/retinanet_resnet50_fpn_coco-eeacb38b.pthizJhttps://github.com/pytorch/vision/tree/main/references/detection#retinanet COCO-val2017box_mapg333333B@gzGb@gCH`@zSThese weights were produced by following a similar training recipe as on the paper. num_paramsrecipe_metrics_ops _file_size_docsurl transformsmetaNrjrkrlrr _COMMON_METACOCO_V1DEFAULTr*r/r-r#r#sN Z"    "bt! !n  G"Gr/r#c DeZdZedeiedddddiiddd d  ZeZy ) r$zOhttps://download.pytorch.org/models/retinanet_resnet50_fpn_v2_coco-5905b1c5.pthiFz+https://github.com/pytorch/vision/pull/5756r@rAgD@gV-c@gw/Ab@zZThese weights were produced using an enhanced training recipe to boost the model accuracy.rBrINrMr*r/r-r$r$sN ]"    "Ct! !u  G"Gr/r$ pretrainedpretrained_backbone)rweights_backboneT)rprogressr\rTtrainable_backbone_layersrrUr\rTrVrc tj|}tj|}|&d}td|t |j d}n|d}|duxs|du}t ||dd}|rtjntj}t|||}t||gdtd d  }t||fi|} |A| j|j!|d |tj"k(r t%| d | S)a Constructs a RetinaNet model with a ResNet-50-FPN backbone. .. betastatus:: detection module Reference: `Focal Loss for Dense Object Detection `_. The input to the model is expected to be a list of tensors, each of shape ``[C, H, W]``, one for each image, and should be in ``0-1`` range. Different images can have different sizes. The behavior of the model changes depending on if it is in training or evaluation mode. During training, the model expects both the input tensors and targets (list of dictionary), containing: - boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. - labels (``Int64Tensor[N]``): the class label for each ground-truth box The model returns a ``Dict[Tensor]`` during training, containing the classification and regression losses. During inference, the model requires only the input tensors, and returns the post-processed predictions as a ``List[Dict[Tensor]]``, one for each input image. The fields of the ``Dict`` are as follows, where ``N`` is the number of detections: - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. - labels (``Int64Tensor[N]``): the predicted labels for each detection - scores (``Tensor[N]``): the scores of each detection For more details on the output, you may refer to :ref:`instance_seg_output`. Example:: >>> model = torchvision.models.detection.retinanet_resnet50_fpn(weights=RetinaNet_ResNet50_FPN_Weights.DEFAULT) >>> model.eval() >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)] >>> predictions = model(x) Args: weights (:class:`~torchvision.models.detection.RetinaNet_ResNet50_FPN_Weights`, optional): The pretrained weights to use. See :class:`~torchvision.models.detection.RetinaNet_ResNet50_FPN_Weights` below for more details, and possible values. By default, no pre-trained weights are used. progress (bool): If True, displays a progress bar of the download to stderr. Default is True. num_classes (int, optional): number of output classes of the model (including the background) weights_backbone (:class:`~torchvision.models.ResNet50_Weights`, optional): The pretrained weights for the backbone. trainable_backbone_layers (int, optional): number of trainable (not frozen) layers starting from final block. Valid values are between 0 and 5, with 5 meaning all backbone layers are trainable. If ``None`` is passed (the default) this value is set to 3. **kwargs: parameters passed to the ``torchvision.models.detection.RetinaNet`` base class. Please refer to the `source code `_ for more details about this class. .. autoclass:: torchvision.models.detection.RetinaNet_ResNet50_FPN_Weights :members: Nr\r>[r )rrUrPrr r1rEreturned_layers extra_blocksTrU check_hashg)r#verifyrrrIrLr r{FrozenBatchNorm2dr BatchNorm2drrrr"load_state_dictget_state_dictrOr) rrUr\rTrVr is_trainedrPrmodels r-r%r%sV-33G`_. :func:`~torchvision.models.detection.retinanet_resnet50_fpn` for more details. Args: weights (:class:`~torchvision.models.detection.RetinaNet_ResNet50_FPN_V2_Weights`, optional): The pretrained weights to use. See :class:`~torchvision.models.detection.RetinaNet_ResNet50_FPN_V2_Weights` below for more details, and possible values. By default, no pre-trained weights are used. progress (bool): If True, displays a progress bar of the download to stderr. Default is True. num_classes (int, optional): number of output classes of the model (including the background) weights_backbone (:class:`~torchvision.models.ResNet50_Weights`, optional): The pretrained weights for the backbone. trainable_backbone_layers (int, optional): number of trainable (not frozen) layers starting from final block. Valid values are between 0 and 5, with 5 meaning all backbone layers are trainable. If ``None`` is passed (the default) this value is set to 3. **kwargs: parameters passed to the ``torchvision.models.detection.RetinaNet`` base class. Please refer to the `source code `_ for more details about this class. .. autoclass:: torchvision.models.detection.RetinaNet_ResNet50_FPN_V2_Weights :members: Nr\r>rXrYr )rrUrZirEr[rrBrRgiou)rLrTr^)r$r`rrrIrLr rrrrMrOrrrr GroupNormrXrr"rcrd) rrUr\rTrVrrerrLrrfs r-r&r&=sDZ066w?G'../?@+M;GLLYeLfHgh   $D(8(DJ ::G`bcef g 08DH$+YUbcgilUmH*+ 113A62<<,  D '-D# h d>NUY d]c dE g44hSW4XY Lr/)Crr( collectionsr functoolsrtypingrrrrrr opsr rr r{r ops.feature_pyramid_networkrtransforms._presetsrutilsr_apirrr_metarrrrresnetrrrrr anchor_utilsrbackbone_utilsrr rr!__all__r!r.r<rMrnrOrUrWr"rNr#r$rO IMAGENET1K_V1boolr?r%r&r*r/r-rzsT #** LL82(77$C/!,)M/ DLV>gBIIg