a PSic% @sddlZddlZddlmZddlmZddlmZmZm Z m Z m Z m Z ddl Z ddl mZmZddlmZmZddlmZdd lmZdd lmZdd lmZdd lmZd dlmZmZd dl m!Z!d dl"m#Z#m$Z$d dl%m&Z&m'Z'ddl(m"Z)ddl*m+Z+ddl,m-Z-m.Z.ddl/m0Z0gdZ1Gdddej2Z3Gdddej2Z4Gdddej2Z5Gdddej2Z6Gd d!d!eZ7e#d"e7j8fd#e&j9fd$dd%de&j9dd&e e7e:e e;e e&e e;ee6d'd(d)ZiZ?dS),N) OrderedDict)partial)AnyCallableDictListTupleOptional)nnTensor)sigmoid_focal_lossgeneralized_box_iou_loss)boxes)misc) LastLevelP6P7)ObjectDetection)_log_api_usage_once) WeightsEnumWeights)_COCO_CATEGORIES)handle_legacy_interface_ovewrite_value_param)ResNet50_Weightsresnet50)_utils)AnchorGenerator)_resnet_fpn_extractor_validate_trainable_layers)GeneralizedRCNNTransform)FCOSFCOS_ResNet50_FPN_Weightsfcos_resnet50_fpncseZdZdZdejiZdeeeeeddfdd Z e e e e fe e e fe e e e e e e fdd d Ze e e e e fd d d ZZS)FCOSHeadaT A regression and classification head for use in FCOS. 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 num_convs (Optional[int]): number of conv layer of head. Default: 4. box_coderN) in_channels num_anchors num_classes num_convsreturncs:ttjdd|_t|||||_t||||_dS)NTnormalize_by_size) super__init__ det_utilsBoxLinearCoderr&FCOSClassificationHeadclassification_headFCOSRegressionHeadregression_head)selfr(r)r*r+ __class__]/var/www/html/django/DPS/env/lib/python3.9/site-packages/torchvision/models/detection/fcos.pyr00s zFCOSHead.__init__)targets head_outputsanchors matched_idxsr,csR|d}|d}|d}g}g} t||D]\} } t| ddkrn| dt| f} | dt| df} n(| d| jdd} | d| jdd} d | | dk<|| | | q*t|}|dk}|}t |} d | |||f<t || d d }fd dt||D}t t|| t| |d d }fddt|| D}tj|dd}t|dkr|| dd }nz|ddddddgf}|ddddddgf}t|jd dd|jd dd|jd dd|jd dd}|jdd}tjj||||d d }|td||td||td|dS)N cls_logitsbbox_regression bbox_ctrnesslabelsrrr')min?sum) reductioncsg|]\}}j||qSr:)r& decode_single).0anchors_per_imagebbox_regression_per_imager7r:r; [sz)FCOSHead.compute_loss..csg|]\}}j||qSr:)r& encode_single)rJrKZboxes_targets_per_imagerMr:r;rNgsdimrrr )classificationrArB)ziplen new_zerosclipappendtorchstackrGitem zeros_liker rfloatsizesqrtrDmaxsqueezer functional binary_cross_entropy_with_logits)r7r<r=r>r?r@rArBZall_gt_classes_targetsZall_gt_boxes_targetstargets_per_imagematched_idxs_per_imageZgt_classes_targetsZgt_boxes_targetsZforegroud_maskZnum_foregroundZloss_cls pred_boxesZ loss_bbox_regZbbox_reg_targetsZgt_ctrness_targetsZ left_rightZ top_bottomZpred_centernessZloss_bbox_ctrnessr:rMr; compute_loss6sb             zFCOSHead.compute_lossxr,cCs$||}||\}}|||dS)N)r@rArB)r4r6)r7rhr@rArBr:r:r;forwards  zFCOSHead.forward)r')__name__ __module__ __qualname____doc__r1r2__annotations__intr r0rrstrr rfri __classcell__r:r:r8r;r%!s    Jr%c sVeZdZdZd eeeeeeedej fddfdd Z e e e d d d Z ZS) r3a A classification head for use in FCOS. 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. num_convs (Optional[int]): number of conv layer. Default: 4. prior_probability (Optional[float]): probability of prior. Default: 0.01. norm_layer: Module specifying the normalization layer to use. r'{Gz?N.)r(r)r*r+prior_probability norm_layerr,c st||_||_|dur*ttjd}g}t|D]:}|tj ||dddd||||t q6tj ||_ |j D]6} t| tj rtjjj| jddtjj| jdqtj |||dddd|_tjjj|jjddtjj|jjtd|| dS)N r r kernel_sizestridepaddingrrstdr)r/r0r*r)rr GroupNormrangerWConv2dReLU Sequentialconvchildren isinstancerXinitnormal_weight constant_biasr@mathlog) r7r(r)r*r+rsrtr_layerr8r:r;r0s$     zFCOSClassificationHead.__init__rgc Cs~g}|D]f}||}||}|j\}}}}||d|j||}|ddddd}||d|j}||qtj |ddS)NrErr r'rrrP) rr@shapeviewr*permutereshaperWrXcat) r7rhZall_cls_logitsfeaturesr@NrHWr:r:r;ris   zFCOSClassificationHead.forward)r'rrN)rjrkrlrmror\r rr Moduler0rr rirqr:r:r8r;r3s!r3csXeZdZdZd eeeeedejfdfdd Z e e e e e fdd d Z ZS) r5a A regression head for use in FCOS, which combines regression branch and center-ness branch. This can obtain better performance. Reference: `FCOS: A simple and strong anchor-free object detector `_. Args: in_channels (int): number of channels of the input feature num_anchors (int): number of anchors to be predicted num_convs (Optional[int]): number of conv layer. Default: 4. norm_layer: Module specifying the normalization layer to use. r'N.)r(r)r+rtc s t|durttjd}g}t|D]:}|tj||dddd||||tq*tj ||_ tj||ddddd|_ tj||ddddd|_ |j |j fD](}t jjj|jddt jj|jq|j D]4}t|tjrt jjj|jddt jj|jqdS)Nrur rrvr'rrrz)r/r0rr r|r}rWr~rrrbbox_regrBrXrrrzeros_rrr)r7r(r)r+rtrrrr8r:r;r0s$     zFCOSRegressionHead.__init__rgc Csg}g}|D]}||}tj||}||}|j\}} } } ||dd| | }|ddddd}| |dd}| |||dd| | }|ddddd}| |dd}| |q t j |ddt j |ddfS)NrEr'rr rrrP) rr rarelurrBrrrrrWrXr) r7rhZall_bbox_regressionZall_bbox_ctrnessrZ bbox_featurerArBrrrrr:r:r;ris     zFCOSRegressionHead.forward)r'N)rjrkrlrmror rr rr0rr rrirqr:r:r8r;r5sr5csneZdZdZdejiZdeje e e e e e e e e e e e eje e e e e d fd d Zejjeeefe eeefeeeefe eeeffdddZe eeefeeefe ee e eeefdddZeee efe e ee ee e fe eeefdddZde ee e eeefeeeefe eeeffdddZZS)r"a Implements FCOS. 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 if it is in training or evaluation mode. During training, the model expects both the input tensors, as well as a 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, regression and centerness 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: - 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 image - scores (Tensor[N]): the scores for each prediction Args: backbone (nn.Module): the network used to compute the features for the model. It should contain an out_channels attribute, which indicates the number of output channels that each feature map has (and it should be the same for all feature maps). The backbone should return a single Tensor or an OrderedDict[Tensor]. num_classes (int): number of output classes of the model (including the background). min_size (int): minimum size of the image to be rescaled before feeding it to the backbone max_size (int): maximum size of the image to be rescaled before feeding it to the backbone image_mean (Tuple[float, float, float]): mean values used for input normalization. They are generally the mean values of the dataset on which the backbone has been trained on image_std (Tuple[float, float, float]): std values used for input normalization. They are generally the std values of the dataset on which the backbone has been trained on anchor_generator (AnchorGenerator): module that generates the anchors for a set of feature maps. For FCOS, only set one anchor for per position of each level, the width and height equal to the stride of feature map, and set aspect ratio = 1.0, so the center of anchor is equivalent to the point in FCOS paper. head (nn.Module): Module run on top of the feature pyramid. Defaults to a module containing a classification and regression module. center_sampling_radius (int): radius of the "center" of a groundtruth box, within which all anchor points are labeled positive. score_thresh (float): Score threshold used for postprocessing the detections. nms_thresh (float): NMS threshold used for postprocessing the detections. detections_per_img (int): Number of best detections to keep after NMS. topk_candidates (int): Number of best detections to keep before NMS. Example: >>> import torch >>> import torchvision >>> from torchvision.models.detection import FCOS >>> 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 >>> # FCOS 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=((8,), (16,), (32,), (64,), (128,)), >>> aspect_ratios=((1.0,),) >>> ) >>> >>> # put the pieces together inside a FCOS model >>> model = FCOS( >>> backbone, >>> num_classes=80, >>> anchor_generator=anchor_generator, >>> ) >>> model.eval() >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)] >>> predictions = model(x) r& 5N?皙?333333?d) backboner*min_sizemax_size image_mean image_stdanchor_generatorheadcenter_sampling_radius score_thresh nms_threshdetections_per_imgtopk_candidatesc s0tt|t|ds$td||_t|ttdfsNt dt||durpd}dt |}t||}||_ |j ddkrtd| d|durt |j| d|}||_tjd d |_|durgd }|durgd }t||||fi||_| |_| |_| |_| |_| |_d |_dS)N out_channelszbackbone should contain an attribute out_channels specifying the number of output channels (assumed to be the same for all the levels)zIanchor_generator should be of type AnchorGenerator or None, instead got ))))ru)@)))rFrrzFanchor_generator.num_anchors_per_location()[0] should be 1 instead of Tr-)g ףp= ?gv/?gCl?)gZd;O?gy&1?g?F)r/r0rhasattr ValueErrorrrrtype TypeErrorrTrnum_anchors_per_locationr%rrr1r2r&r! transformrrrrr _has_warned)r7rr*rrrrrrrrrrrkwargs anchor_sizes aspect_ratiosr8r:r;r0jsF     z FCOS.__init__)losses detectionsr,cCs|jr |S|S)N)training)r7rrr:r:r; eager_outputsszFCOS.eager_outputs)r<r=r>num_anchors_per_levelr,c Csg}t||D]t\}}|ddkrN|tj|dfdtj|jdq|d}|ddddf|ddddfd} |ddddf|ddddfd} |dddf|dddf} | dddddf| dddddfj ddj |j | dddfk} | j ddj dd\} }|j ddj dd\}}}}tj| ||||| ||gdd}| |jddj dkM} | d}d|d|d<| d }td ||d d<|j ddj }| ||dddfk||dddfk@M} |dddf|dddf|ddd f|dddf}| tjd |dddf} | j dd\}}d||d k<||q|j||||S)NrrrE)dtypedevicerrPrr'rinfr gחAgh㈵>)rSnumelrWrXfullr]int64rabs_r_valuesr unsqueezeunbindrYrDr\tofloat32rrf)r7r<r=r>rr?rKrcgt_boxesZ gt_centersZanchor_centersrZpairwise_matchrhyx0y0x1y1Z pairwise_dist lower_bound upper_boundZgt_areasZ min_valuesZ matched_idxr:r:r;rfs@,, 0&,@   zFCOS.compute_loss)r=r> image_shapesr,cs|d}|d}|d}t|}g}t|D]fdd|D} fdd|D} fdd|D} ||} } g}g}g}t| | | | D]\}}}}|jd}tt|t|}||jk}||}t |d }t ||j d }| |\}}||}tj||d d }||}|j||||}t|| }||||||qtj|d d }tj|d d }tj|d d }t||||j}|d|j}|||||||d q,|S)Nr@rArBcsg|] }|qSr:r:)rJbrindexr:r;rNz/FCOS.postprocess_detections..csg|] }|qSr:r:)rJclrr:r;rNrcsg|] }|qSr:r:)rJbcrr:r;rNrrErfloor) rounding_moderP)rscoresrC)rTr}rSrrXr^sigmoidflattenrwherer1 _topk_minrtopkdivr&rIbox_opsclip_boxes_to_imagerWr batched_nmsrr)r7r=r>r class_logitsbox_regressionZ box_ctrness num_imagesrZbox_regression_per_imageZlogits_per_imageZbox_ctrness_per_imagerK image_shapeZ image_boxesZ image_scoresZ image_labelsbox_regression_per_levelZlogits_per_levelZbox_ctrness_per_levelZanchors_per_levelr*Zscores_per_levelZ keep_idxsZ topk_idxsZnum_topkidxsZ anchor_idxsZlabels_per_levelZboxes_per_levelkeepr:rr;postprocess_detectionss^       zFCOS.postprocess_detections)imagesr<r,c s|jrp|durtddnT|D]N}|d}tt|tjdtt|jdko^|jddkd |jd q g}|D]L}|jd d}tt|dkd |jd d||d |dfqx|||\}}|durjt |D]\}}|d}|ddddf|ddddfk} | rt | j ddd d } ||  } tdd| d|d q| |j} t| tjrtd| fg} t| } || } ||| }dd| Di}g}|jr|durtddn||| |}n^i}| D] }t| |jdd||<qfdd|D}||||j}|j||j|}tjr|js~tdd|_||fS|||S)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 moderz+Expected target boxes to be of type Tensor.rrEr'z:Expected target boxes to be a tensor of shape [N, 4], got .zJexpecting the last two dimensions of the Tensor to be H and W instead got rrrPzLAll bounding boxes should have positive height and width. Found invalid box z for target at index 0cSs g|]}|d|dqS)rr )r])rJrhr:r:r;rNorz FCOS.forward..csg|]}t|qSr:)listsplit)rJarr:r;rN~rz=FCOS always returns a (Losses, Detections) tuple in scriptingT)rrX_assertrr rTrrWr enumerateanyrtolistrtensorsrrrrrrfrr image_sizes postprocessjit is_scriptingrwarningswarnr)r7rr<targetroriginal_image_sizesimgval target_idxdegenerate_boxesbb_idxdegen_bbrr=r>rrZsplit_head_outputskZ split_anchorsr:rr;ri+sn   (        z FCOS.forward) rrNNNNrrrrr)N)rjrkrlrmr1r2rnr rror rr\rr0rXrunusedrrpr rrrfrrirqr:r:r8r;r"s`W   B   2& Hr"c @s4eZdZedededddddiidd d ZeZd S) r#zGhttps://download.pytorch.org/models/fcos_resnet50_fpn_coco-99b0c9b7.pthi e)rrzShttps://github.com/pytorch/vision/tree/main/references/detection#fcos-resnet-50-fpnz COCO-val2017box_mapgC@zSThese weights were produced by following a similar training recipe as on the paper.) num_params categoriesrrecipe_metrics_docs)url transformsmetaN)rjrkrlrrrCOCO_V1DEFAULTr:r:r:r;r#sr# pretrainedpretrained_backbone)weightsweights_backboneT)rprogressr*rtrainable_backbone_layers)rrr*rrrr,c Kst|}t|}|dur6d}t|t|jd}n |durBd}|dupP|du}t||dd}|rjtjnt j }t |||d}t ||gdt ddd }t||fi|} |dur| |j|d | S) a Constructs a FCOS model with a ResNet-50-FPN backbone. .. betastatus:: detection module Reference: `FCOS: Fully Convolutional One-Stage Object Detection `_. `FCOS: A simple and strong anchor-free object detector `_. 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 if it is in training or evaluation mode. During training, the model expects both the input tensors, as well as a 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.fcos_resnet50_fpn(weights=FCOS_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.FCOS_ResNet50_FPN_Weights`, optional): The pretrained weights to use. See :class:`~torchvision.models.detection.FCOS_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 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) resnet 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. Default: None **kwargs: parameters passed to the ``torchvision.models.detection.FCOS`` base class. Please refer to the `source code `_ for more details about this class. .. autoclass:: torchvision.models.detection.FCOS_ResNet50_FPN_Weights :members: Nr[r )rrrt)rr r')returned_layers extra_blocks)r)r#verifyrrrTrr misc_nn_opsFrozenBatchNorm2dr BatchNorm2drrrr"load_state_dictget_state_dict) rrr*rrr is_trainedrtrmodelr:r:r;r$s$K  r$) _ModelURLsZfcos_resnet50_fpn_coco)@rr collectionsr functoolsrtypingrrrrrr rXr r opsr rrrrr$Zops.feature_pyramid_networkrZtransforms._presetsrutilsr_apirr_metarrrrresnetrrr1 anchor_utilsrbackbone_utilsrr rr!__all__rr%r3r5r"r#r IMAGENET1K_V1boolror$r+r model_urlsr:r:r:r;sh            i@Ea