o ߥim@sddlmZmZddlZddlZddlZddlmZddl mm Z ddl m Z ddlmZmZmZGdddejZ     dd d ZGd d d ejZGd ddeZGdddeedZGdddeZGdddejZdS))ABCMetaabstractmethodN) ConvModule) BaseModule auto_fp16 force_fp32cs$eZdZfddZddZZS)LinearClassifiercs tt|t|||_dSN)superr__init__nnLinear classifier)self in_channels num_classes __class___/home/ubuntu/.local/lib/python3.10/site-packages/modelscope/models/cv/vision_middleware/head.pyr szLinearClassifier.__init__cCs||dS)N)rrxrrrforwardszLinearClassifier.forward__name__ __module__ __qualname__r r __classcell__rrrrrs rnearestTcCst|||||Sr )F interpolate)inputsize scale_factormode align_cornerswarningrrrresizesr(cs.eZdZ    dfdd ZddZZS)UpsampleNrcsVtt|||_t|trtdd|D|_n |r t|nd|_||_||_ dS)Ncss|]}t|VqdSr )float).0factorrrr /sz$Upsample.__init__..) r r)r r# isinstancetupler$r*r%r&)rr#r$r%r&rrrr 's  zUpsample.__init__cs>jsfdd|jddD}nj}t||djjS)Ncsg|] }t|jqSr)intr$)r+trrr 7sz$Upsample.forward..)r#shaper(r%r&)rrr#rr2rr5szUpsample.forward)NNrNrrrrrr)%sr)csVeZdZdZdddddddddeddedd d d f fd d ZeddZZS)FPNa Feature Pyramid Network. This neck is the implementation of `Feature Pyramid Networks for Object Detection `_. Args: in_channels (list[int]): Number of input channels per scale. out_channels (int): Number of output channels (used at each scale). num_outs (int): Number of output scales. start_level (int): Index of the start input backbone level used to build the feature pyramid. Default: 0. end_level (int): Index of the end input backbone level (exclusive) to build the feature pyramid. Default: -1, which means the last level. add_extra_convs (bool | str): If bool, it decides whether to add conv layers on top of the original feature maps. Default to False. If True, its actual mode is specified by `extra_convs_on_inputs`. If str, it specifies the source feature map of the extra convs. Only the following options are allowed - 'on_input': Last feat map of neck inputs (i.e. backbone feature). - 'on_lateral': Last feature map after lateral convs. - 'on_output': The last output feature map after fpn convs. extra_convs_on_inputs (bool, deprecated): Whether to apply extra convs on the original feature from the backbone. If True, it is equivalent to `add_extra_convs='on_input'`. If False, it is equivalent to set `add_extra_convs='on_output'`. Default to True. relu_before_extra_convs (bool): Whether to apply relu before the extra conv. Default: False. no_norm_on_lateral (bool): Whether to apply norm on lateral. Default: False. conv_cfg (dict): Config dict for convolution layer. Default: None. norm_cfg (dict): Config dict for normalization layer. Default: None. act_cfg (dict): Config dict for activation layer in ConvModule. Default: None. upsample_cfg (dict): Config dict for interpolate layer. Default: dict(mode='nearest'). init_cfg (dict or list[dict], optional): Initialization config dict. Example: >>> import torch >>> in_channels = [2, 3, 5, 7] >>> scales = [340, 170, 84, 43] >>> inputs = [torch.rand(1, c, s, s) ... for c, s in zip(in_channels, scales)] >>> self = FPN(in_channels, 11, len(in_channels)).eval() >>> outputs = self.forward(inputs) >>> for i in range(len(outputs)): ... print(f'outputs[{i}].shape = {outputs[i].shape}') outputs[0].shape = torch.Size([1, 11, 340, 340]) outputs[1].shape = torch.Size([1, 11, 170, 170]) outputs[2].shape = torch.Size([1, 11, 84, 84]) outputs[3].shape = torch.Size([1, 11, 43, 43]) rrFNr)r%XavierConv2duniform)typelayer distributionc stt||t|tsJ||_||_t||_||_ ||_ | |_ d|_ | |_|dkr=|j|_||j|ks.r@rrr$rGr#csg|] }j||qSr)r[r+r`)lateralsrrrr3s)rHr=r>r?)rKr enumeraterZr\rRr(r5rMrVr]r max_pool2drSNotImplementedErrorr[rNrelur/)rrgused_backbone_levelsr` prev_shapeouts extra_sourcer)rgrirrrsR           z FPN.forward) rrr__doc__dictr rrrrrrrr6=s$6_r6cseZdZdZdddddeddddeddd d d dded d edddd fdd ZddZddZddZe e ddZ ddZ ddZ d d!ZZS)"BaseDecodeHeadaBase class for BaseDecodeHead. Args: in_channels (int|Sequence[int]): Input channels. channels (int): Channels after modules, before conv_seg. num_classes (int): Number of classes. out_channels (int): Output channels of conv_seg. threshold (float): Threshold for binary segmentation in the case of `out_channels==1`. Default: None. dropout_ratio (float): Ratio of dropout layer. Default: 0.1. conv_cfg (dict|None): Config of conv layers. Default: None. norm_cfg (dict|None): Config of norm layers. Default: None. act_cfg (dict): Config of activation layers. Default: dict(type='ReLU') in_index (int|Sequence[int]): Input feature index. Default: -1 input_transform (str|None): Transformation type of input features. Options: 'resize_concat', 'multiple_select', None. 'resize_concat': Multiple feature maps will be resize to the same size as first one and than concat together. Usually used in FCN head of HRNet. 'multiple_select': Multiple feature maps will be bundle into a list and passed into decode head. None: Only one select feature map is allowed. Default: None. loss_decode (dict | Sequence[dict]): Config of decode loss. The `loss_name` is property of corresponding loss function which could be shown in training log. If you want this loss item to be included into the backward graph, `loss_` must be the prefix of the name. Defaults to 'loss_ce'. e.g. dict(type='CrossEntropyLoss'), [dict(type='CrossEntropyLoss', loss_name='loss_ce'), dict(type='DiceLoss', loss_name='loss_dice')] Default: dict(type='CrossEntropyLoss'). ignore_index (int | None): The label index to be ignored. When using masked BCE loss, ignore_index should be set to None. Default: 255. sampler (dict|None): The config of segmentation map sampler. Default: None. align_corners (bool): align_corners argument of F.interpolate. Default: False. init_cfg (dict or list[dict], optional): Initialization config dict. N皙?ReLU)r:rCrossEntropyLossF?r: use_sigmoid loss_weightNormalg{Gz?conv_seg)name)r:stdoverride) rJ threshold dropout_ratiorArBrCin_indexinput_transform loss_decode ignore_indexsamplerr&r_cstt||||| | ||_||_||_||_| |_| |_ | |_ ||_ |dur6|dkr4t d|}||krH|dkrHtd|d||dkrW|durWd}t d||_||_||_tj||jdd|_|d krut||_nd|_d |_dS) NrGzFor binary segmentation, we suggest using`out_channels = 1` to define the outputchannels of segmentor, and use `threshold`to convert seg_logist into a predictionapplying a thresholdr@zout_channels should be equal to num_classes,except binary segmentation set out_channels == 1 andnum_classes == 2, but got out_channels=zand num_classes=g333333?z7threshold is not defined for binary, and defaultsto 0.3) kernel_sizerF)r rtr _init_inputschannelsrrArBrCrrr&warningswarn ValueErrorrrJrr r8r~ Dropout2ddropoutrP)rrrrrJrrrArBrCrrrrrr&r_rrrr /sB   zBaseDecodeHead.__init__cCs d|jd|jd|j}|S)z Extra repr.zinput_transform=z, ignore_index=z, align_corners=)rrr&)rsrrr extra_reprps zBaseDecodeHead.extra_reprcCs|dur |dvs J||_||_|dur@t|ttfsJt|ttfs&Jt|t|ks0J|dkr;t||_dS||_dSt|tsGJt|tsNJ||_dS)aCheck and initialize input transforms. The in_channels, in_index and input_transform must match. Specifically, when input_transform is None, only single feature map will be selected. So in_channels and in_index must be of type int. When input_transform Args: in_channels (int|Sequence[int]): Input channels. in_index (int|Sequence[int]): Input feature index. input_transform (str|None): Transformation type of input features. Options: 'resize_concat', 'multiple_select', None. 'resize_concat': Multiple feature maps will be resize to the same size as first one and than concat together. Usually used in FCN head of HRNet. 'multiple_select': Multiple feature maps will be bundle into a list and passed into decode head. None: Only one select feature map is allowed. N) resize_concatmultiple_selectr) rrr.rIr/rKsumrr0)rrrrrrrrws   zBaseDecodeHead._init_inputscstjdkr"fddjDfddD}tj|ddSjdkr3fddjDSjS) zTransform inputs for decoder. Args: inputs (list[Tensor]): List of multi-level img features. Returns: Tensor: The transformed inputs rcg|]}|qSrrrhrgrrr3z4BaseDecodeHead._transform_inputs..cs,g|]}t|djdddjdqS)rrGNbilinear)r"r#r%r&)r(r5r&)r+rrfrrr3sr@dimrcrrrrhrrrr3r)rrtorchcat)rrgupsampled_inputsrrfr_transform_inputss    z BaseDecodeHead._transform_inputscCsdS)z Placeholder of forward function.Nr)rrgrrrrszBaseDecodeHead.forwardcCs||}|||}|S)aForward function for training. Args: inputs (list[Tensor]): List of multi-level img features. img_metas (list[dict]): List of image info dict where each dict has: 'img_shape', 'scale_factor', 'flip', and may also contain 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. For details on the values of these keys see `mmseg/datasets/pipelines/formatting.py:Collect`. gt_semantic_seg (Tensor): Semantic segmentation masks used if the architecture supports semantic segmentation task. train_cfg (dict): The training config. Returns: dict[str, Tensor]: a dictionary of loss components )losses)rrg img_metasgt_semantic_seg train_cfg seg_logitsrrrr forward_trains zBaseDecodeHead.forward_traincCs ||S)aKForward function for testing. Args: inputs (list[Tensor]): List of multi-level img features. img_metas (list[dict]): List of image info dict where each dict has: 'img_shape', 'scale_factor', 'flip', and may also contain 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. For details on the values of these keys see `mmseg/datasets/pipelines/formatting.py:Collect`. test_cfg (dict): The testing config. Returns: Tensor: Output segmentation map. )r)rrgrtest_cfgrrr forward_tests zBaseDecodeHead.forward_testcCs"|jdur ||}||}|S)zClassify each pixel.N)rr~)rfeatoutputrrrcls_segs   zBaseDecodeHead.cls_seg)rrrrrrsr rrrrrrrrrrrrrrrts>. A$ rt) metaclasscs(eZdZdZfddZddZZS)FPNHeadaOPanoptic Feature Pyramid Networks. This head is the implementation of `Semantic FPN `_. Args: feature_strides (tuple[int]): The strides for input feature maps. stack_lateral. All strides suppose to be power of 2. The first one is of largest resolution. c stt|jd ddi|t|t|jksJt||dks"J||_t|_ t t|D]V}t dt t ||t |d}g}t |D]1}|t|dkrY|j|n|j|jdd|j|j|jd|||dkr||tdd|jd qK|j tj|q0dS) Nrrrr@rE)rFrArBrCrGr)r$r%r&r)r rr rKrminfeature_stridesr rY scale_headsr\maxr0nplog2r]rrrArBrCr)r& Sequential)rrkwargsr` head_length scale_headkrrrr sL   zFPNHead.__init__cCsn||}|jd|d}tdt|jD]}|t|j||||jddd|jd}q||}|S)Nrr@rGr)r#r%r&) rrr\rKrr(r5r&r)rrgrrr`rrrr s   zFPNHead.forward)rrrrrr rrrrrrrs rcseZdZdZdegddddegdgdgd d d d ed dddeddddd ffdd Z      dddZddZZS) FPNSegmentorz Packed Sementor Head Args: fpn_layer_indices: tuple of the indices of layers neck_cfg: dict of FPN params head_cfg: dict of FPNHead params )rE )rrr)rrJrM)rrrr)rr@rGrE)r ruBNT)r: requires_gradFrwrxry) rrrrrrrBr&rc stt|||_|dd}tttj||dddt|t tj||dddtj||dddt tj dddg|_ t d i||_td i||_|d|_tj}tjdtjjdd|jdfd }tj|||_dS) NrrrG)rrHr*r|rEr#r)r rr fpn_layer_indicesr rYrConvTranspose2d BatchNorm2dGELUIdentity MaxPool2dpre_fpnr6fpn_neckrfpn_head NUM_CLASSESrrandom get_stateseedrandint set_statePALETTE)rrneck_cfghead_cfgwidthstatepaletterrrr 's,        zFPNSegmentor.__init__Nr?c Cst|}|}|} |dur5|jdur2tj} tjdtjjdd|j dfd}tj | n|j}t |}|j d|j ksDJ|j ddksMJt |j dksVJd|krad ksdJJ| j d|j ksnJ| j d|j dks| j d|j dkrt| |j d|j dfdd d } | d} tj| dd } tj| j d| j ddftjd } t|D]\} } | | | | kddf<q| ddddf} |d|| |}|tj}|durd}|rt||||durt|||s|stddSdSdS)aDraw `result` over `img`. Args: img (str or Tensor): The image to be displayed. result (Tensor): The semantic segmentation results to draw over `img`. palette (list[list[int]]] | np.ndarray | None): The palette of segmentation map. If None is given, random palette will be generated. Default: None win_name (str): The window name. wait_time (int): Value of waitKey param. Default: 0. show (bool): Whether to show the image. Default: False. out_file (str or None): The filename to write the image. Default: None. opacity(float): Opacity of painted segmentation map. Default 0.5. Must be in (0, 1] range. Returns: img (Tensor): Only if not `show` or `out_file` Nrrr|rErr@rGrxrTr)dtype.rFzMshow==False and out_file is not specified, only result image will be returned)mmcvimreadrQrrrrrrrrarrayr5rKr(rargmaxzerosuint8rjastypeimshowimwriterr)rimgresultrwin_nameshow wait_timeout_fileopacitysegr color_seglabelcolorrrr show_resultVsL     ("    zFPNSegmentor.show_resultcsHfddjDfddttDS)Ncrrr)r+idx)rrrr3rz(FPNSegmentor.forward..csg|] }j||qSr)rrhrrrr3s)rr\rKrrrrrrrs   zFPNSegmentor.forward)NrFrNr) rrrrrrsr rrrrrrrrs@  2 Sr)NNrNT)abcrrrnumpyrrtorch.nnr torch.nn.functional functionalr mmcv.cnnr mmcv.runnerrrrModulerr(r)r6rtrrrrrrs,     I`: