paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/paddleseg/models/ocrnet.py

@@ -1,248 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-from paddlex.paddleseg import utils
-from paddlex.paddleseg.cvlibs import manager, param_init
-from paddlex.paddleseg.models import layers
-
-
-@manager.MODELS.add_component
-class OCRNet(nn.Layer):
-    """
-    The OCRNet implementation based on PaddlePaddle.
-    The original article refers to
-        Yuan, Yuhui, et al. "Object-Contextual Representations for Semantic Segmentation"
-        (https://arxiv.org/pdf/1909.11065.pdf)
-
-    Args:
-        num_classes (int): The unique number of target classes.
-        backbone (Paddle.nn.Layer): Backbone network.
-        backbone_indices (tuple): A tuple indicates the indices of output of backbone.
-            It can be either one or two values, if two values, the first index will be taken as
-            a deep-supervision feature in auxiliary layer; the second one will be taken as
-            input of pixel representation. If one value, it is taken by both above.
-        ocr_mid_channels (int, optional): The number of middle channels in OCRHead. Default: 512.
-        ocr_key_channels (int, optional): The number of key channels in ObjectAttentionBlock. Default: 256.
-        align_corners (bool): An argument of F.interpolate. It should be set to False when the output size of feature
-            is even, e.g. 1024x512, otherwise it is True, e.g. 769x769.  Default: False.
-        pretrained (str, optional): The path or url of pretrained model. Default: None.
-    """
-
-    def __init__(self,
-                 num_classes,
-                 backbone,
-                 backbone_indices,
-                 ocr_mid_channels=512,
-                 ocr_key_channels=256,
-                 align_corners=False,
-                 pretrained=None):
-        super().__init__()
-
-        self.backbone = backbone
-        self.backbone_indices = backbone_indices
-        in_channels = [
-            self.backbone.feat_channels[i] for i in backbone_indices
-        ]
-
-        self.head = OCRHead(
-            num_classes=num_classes,
-            in_channels=in_channels,
-            ocr_mid_channels=ocr_mid_channels,
-            ocr_key_channels=ocr_key_channels)
-
-        self.align_corners = align_corners
-        self.pretrained = pretrained
-        self.init_weight()
-
-    def forward(self, x):
-        feats = self.backbone(x)
-        feats = [feats[i] for i in self.backbone_indices]
-        logit_list = self.head(feats)
-        if not self.training:
-            logit_list = [logit_list[0]]
-
-        logit_list = [
-            F.interpolate(
-                logit,
-                paddle.shape(x)[2:],
-                mode='bilinear',
-                align_corners=self.align_corners) for logit in logit_list
-        ]
-        return logit_list
-
-    def init_weight(self):
-        if self.pretrained is not None:
-            utils.load_entire_model(self, self.pretrained)
-
-
-class OCRHead(nn.Layer):
-    """
-    The Object contextual representation head.
-
-    Args:
-        num_classes(int): The unique number of target classes.
-        in_channels(tuple): The number of input channels.
-        ocr_mid_channels(int, optional): The number of middle channels in OCRHead. Default: 512.
-        ocr_key_channels(int, optional): The number of key channels in ObjectAttentionBlock. Default: 256.
-    """
-
-    def __init__(self,
-                 num_classes,
-                 in_channels,
-                 ocr_mid_channels=512,
-                 ocr_key_channels=256):
-        super().__init__()
-
-        self.num_classes = num_classes
-        self.spatial_gather = SpatialGatherBlock(ocr_mid_channels, num_classes)
-        self.spatial_ocr = SpatialOCRModule(ocr_mid_channels, ocr_key_channels,
-                                            ocr_mid_channels)
-
-        self.indices = [-2, -1] if len(in_channels) > 1 else [-1, -1]
-
-        self.conv3x3_ocr = layers.ConvBNReLU(
-            in_channels[self.indices[1]], ocr_mid_channels, 3, padding=1)
-        self.cls_head = nn.Conv2D(ocr_mid_channels, self.num_classes, 1)
-        self.aux_head = nn.Sequential(
-            layers.ConvBNReLU(in_channels[self.indices[0]],
-                              in_channels[self.indices[0]], 1),
-            nn.Conv2D(in_channels[self.indices[0]], self.num_classes, 1))
-
-        self.init_weight()
-
-    def forward(self, feat_list):
-        feat_shallow, feat_deep = feat_list[self.indices[0]], feat_list[
-            self.indices[1]]
-
-        soft_regions = self.aux_head(feat_shallow)
-        pixels = self.conv3x3_ocr(feat_deep)
-
-        object_regions = self.spatial_gather(pixels, soft_regions)
-        ocr = self.spatial_ocr(pixels, object_regions)
-
-        logit = self.cls_head(ocr)
-        return [logit, soft_regions]
-
-    def init_weight(self):
-        """Initialize the parameters of model parts."""
-        for sublayer in self.sublayers():
-            if isinstance(sublayer, nn.Conv2D):
-                param_init.normal_init(sublayer.weight, std=0.001)
-            elif isinstance(sublayer, (nn.BatchNorm, nn.SyncBatchNorm)):
-                param_init.constant_init(sublayer.weight, value=1.0)
-                param_init.constant_init(sublayer.bias, value=0.0)
-
-
-class SpatialGatherBlock(nn.Layer):
-    """Aggregation layer to compute the pixel-region representation."""
-
-    def __init__(self, pixels_channels, regions_channels):
-        super().__init__()
-        self.pixels_channels = pixels_channels
-        self.regions_channels = regions_channels
-
-    def forward(self, pixels, regions):
-        # pixels: from (n, c, h, w) to (n, h*w, c)
-        pixels = paddle.reshape(pixels, (0, self.pixels_channels, -1))
-        pixels = paddle.transpose(pixels, (0, 2, 1))
-
-        # regions: from (n, k, h, w) to (n, k, h*w)
-        regions = paddle.reshape(regions, (0, self.regions_channels, -1))
-        regions = F.softmax(regions, axis=2)
-
-        # feats: from (n, k, c) to (n, c, k, 1)
-        feats = paddle.bmm(regions, pixels)
-        feats = paddle.transpose(feats, (0, 2, 1))
-        feats = paddle.unsqueeze(feats, axis=-1)
-
-        return feats
-
-
-class SpatialOCRModule(nn.Layer):
-    """Aggregate the global object representation to update the representation for each pixel."""
-
-    def __init__(self,
-                 in_channels,
-                 key_channels,
-                 out_channels,
-                 dropout_rate=0.1):
-        super().__init__()
-
-        self.attention_block = ObjectAttentionBlock(in_channels, key_channels)
-        self.conv1x1 = nn.Sequential(
-            layers.ConvBNReLU(2 * in_channels, out_channels, 1),
-            nn.Dropout2D(dropout_rate))
-
-    def forward(self, pixels, regions):
-        context = self.attention_block(pixels, regions)
-        feats = paddle.concat([context, pixels], axis=1)
-        feats = self.conv1x1(feats)
-
-        return feats
-
-
-class ObjectAttentionBlock(nn.Layer):
-    """A self-attention module."""
-
-    def __init__(self, in_channels, key_channels):
-        super().__init__()
-
-        self.in_channels = in_channels
-        self.key_channels = key_channels
-
-        self.f_pixel = nn.Sequential(
-            layers.ConvBNReLU(in_channels, key_channels, 1),
-            layers.ConvBNReLU(key_channels, key_channels, 1))
-
-        self.f_object = nn.Sequential(
-            layers.ConvBNReLU(in_channels, key_channels, 1),
-            layers.ConvBNReLU(key_channels, key_channels, 1))
-
-        self.f_down = layers.ConvBNReLU(in_channels, key_channels, 1)
-
-        self.f_up = layers.ConvBNReLU(key_channels, in_channels, 1)
-
-    def forward(self, x, proxy):
-        x_shape = paddle.shape(x)
-        # query : from (n, c1, h1, w1) to (n, h1*w1, key_channels)
-        query = self.f_pixel(x)
-        query = paddle.reshape(query, (0, self.key_channels, -1))
-        query = paddle.transpose(query, (0, 2, 1))
-
-        # key : from (n, c2, h2, w2) to (n, key_channels, h2*w2)
-        key = self.f_object(proxy)
-        key = paddle.reshape(key, (0, self.key_channels, -1))
-
-        # value : from (n, c2, h2, w2) to (n, h2*w2, key_channels)
-        value = self.f_down(proxy)
-        value = paddle.reshape(value, (0, self.key_channels, -1))
-        value = paddle.transpose(value, (0, 2, 1))
-
-        # sim_map (n, h1*w1, h2*w2)
-        sim_map = paddle.bmm(query, key)
-        sim_map = (self.key_channels**-.5) * sim_map
-        sim_map = F.softmax(sim_map, axis=-1)
-
-        # context from (n, h1*w1, key_channels) to (n , out_channels, h1, w1)
-        context = paddle.bmm(sim_map, value)
-        context = paddle.transpose(context, (0, 2, 1))
-        context = paddle.reshape(
-            context, (0, self.key_channels, x_shape[2], x_shape[3]))
-        context = self.f_up(context)
-
-        return context

paddlex/paddleseg/models/pspnet.py

@@ -1,147 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-import paddle
-from paddlex.paddleseg.cvlibs import manager
-from paddlex.paddleseg.models import layers
-from paddlex.paddleseg.utils import utils
-
-
-@manager.MODELS.add_component
-class PSPNet(nn.Layer):
-    """
-    The PSPNet implementation based on PaddlePaddle.
-
-    The original article refers to
-    Zhao, Hengshuang, et al. "Pyramid scene parsing network"
-    (https://openaccess.thecvf.com/content_cvpr_2017/papers/Zhao_Pyramid_Scene_Parsing_CVPR_2017_paper.pdf).
-
-    Args:
-        num_classes (int): The unique number of target classes.
-        backbone (Paddle.nn.Layer): Backbone network, currently support Resnet50/101.
-        backbone_indices (tuple, optional): Two values in the tuple indicate the indices of output of backbone.
-        pp_out_channels (int, optional): The output channels after Pyramid Pooling Module. Default: 1024.
-        bin_sizes (tuple, optional): The out size of pooled feature maps. Default: (1,2,3,6).
-        enable_auxiliary_loss (bool, optional): A bool value indicates whether adding auxiliary loss. Default: True.
-        align_corners (bool, optional): An argument of F.interpolate. It should be set to False when the feature size is even,
-            e.g. 1024x512, otherwise it is True, e.g. 769x769. Default: False.
-        pretrained (str, optional): The path or url of pretrained model. Default: None.
-    """
-
-    def __init__(self,
-                 num_classes,
-                 backbone,
-                 backbone_indices=(2, 3),
-                 pp_out_channels=1024,
-                 bin_sizes=(1, 2, 3, 6),
-                 enable_auxiliary_loss=True,
-                 align_corners=False,
-                 pretrained=None):
-        super().__init__()
-
-        self.backbone = backbone
-        backbone_channels = [
-            backbone.feat_channels[i] for i in backbone_indices
-        ]
-
-        self.head = PSPNetHead(num_classes, backbone_indices,
-                               backbone_channels, pp_out_channels, bin_sizes,
-                               enable_auxiliary_loss, align_corners)
-        self.align_corners = align_corners
-        self.pretrained = pretrained
-        self.init_weight()
-
-    def forward(self, x):
-        feat_list = self.backbone(x)
-        logit_list = self.head(feat_list)
-        return [
-            F.interpolate(
-                logit,
-                paddle.shape(x)[2:],
-                mode='bilinear',
-                align_corners=self.align_corners) for logit in logit_list
-        ]
-
-    def init_weight(self):
-        if self.pretrained is not None:
-            utils.load_entire_model(self, self.pretrained)
-
-
-class PSPNetHead(nn.Layer):
-    """
-    The PSPNetHead implementation.
-
-    Args:
-        num_classes (int): The unique number of target classes.
-        backbone_indices (tuple): Two values in the tuple indicate the indices of output of backbone.
-            The first index will be taken as a deep-supervision feature in auxiliary layer;
-            the second one will be taken as input of Pyramid Pooling Module (PPModule).
-            Usually backbone consists of four downsampling stage, and return an output of
-            each stage. If we set it as (2, 3) in ResNet, that means taking feature map of the third
-            stage (res4b22) in backbone, and feature map of the fourth stage (res5c) as input of PPModule.
-        backbone_channels (tuple): The same length with "backbone_indices". It indicates the channels of corresponding index.
-        pp_out_channels (int): The output channels after Pyramid Pooling Module.
-        bin_sizes (tuple): The out size of pooled feature maps.
-        enable_auxiliary_loss (bool, optional): A bool value indicates whether adding auxiliary loss. Default: True.
-        align_corners (bool): An argument of F.interpolate. It should be set to False when the output size of feature
-            is even, e.g. 1024x512, otherwise it is True, e.g. 769x769.
-    """
-
-    def __init__(self, num_classes, backbone_indices, backbone_channels,
-                 pp_out_channels, bin_sizes, enable_auxiliary_loss,
-                 align_corners):
-
-        super().__init__()
-
-        self.backbone_indices = backbone_indices
-
-        self.psp_module = layers.PPModule(
-            in_channels=backbone_channels[1],
-            out_channels=pp_out_channels,
-            bin_sizes=bin_sizes,
-            dim_reduction=True,
-            align_corners=align_corners)
-
-        self.dropout = nn.Dropout(p=0.1)  # dropout_prob
-
-        self.conv = nn.Conv2D(
-            in_channels=pp_out_channels,
-            out_channels=num_classes,
-            kernel_size=1)
-
-        if enable_auxiliary_loss:
-            self.auxlayer = layers.AuxLayer(
-                in_channels=backbone_channels[0],
-                inter_channels=backbone_channels[0] // 4,
-                out_channels=num_classes)
-
-        self.enable_auxiliary_loss = enable_auxiliary_loss
-
-    def forward(self, feat_list):
-        logit_list = []
-        x = feat_list[self.backbone_indices[1]]
-        x = self.psp_module(x)
-        x = self.dropout(x)
-        logit = self.conv(x)
-        logit_list.append(logit)
-
-        if self.enable_auxiliary_loss:
-            auxiliary_feat = feat_list[self.backbone_indices[0]]
-            auxiliary_logit = self.auxlayer(auxiliary_feat)
-            logit_list.append(auxiliary_logit)
-
-        return logit_list

paddlex/paddleseg/models/sfnet.py

@@ -1,236 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-from paddlex.paddleseg.models import layers
-from paddlex.paddleseg.cvlibs import manager
-from paddlex.paddleseg.utils import utils
-
-
-@manager.MODELS.add_component
-class SFNet(nn.Layer):
-    """
-    The SFNet implementation based on PaddlePaddle.
-
-    The original article refers to
-    Li, Xiangtai, et al. "Semantic Flow for Fast and Accurate Scene Parsing"
-    (https://arxiv.org/pdf/2002.10120.pdf).
-
-    Args:
-        num_classes (int): The unique number of target classes.
-        backbone (Paddle.nn.Layer): Backbone network, currently support Resnet50/101.
-        backbone_indices (tuple): Four values in the tuple indicate the indices of output of backbone.
-        enable_auxiliary_loss (bool, optional): A bool value indicates whether adding auxiliary loss. Default: False.
-        align_corners (bool, optional): An argument of F.interpolate. It should be set to False when the feature size is even,
-            e.g. 1024x512, otherwise it is True, e.g. 769x769. Default: False.
-        pretrained (str, optional): The path or url of pretrained model. Default: None.
-    """
-
-    def __init__(self,
-                 num_classes,
-                 backbone,
-                 backbone_indices,
-                 enable_auxiliary_loss=False,
-                 align_corners=False,
-                 pretrained=None):
-        super(SFNet, self).__init__()
-        self.backbone = backbone
-        self.backbone_indices = backbone_indices
-        self.in_channels = [
-            self.backbone.feat_channels[i] for i in backbone_indices
-        ]
-        self.align_corners = align_corners
-        self.pretrained = pretrained
-        self.enable_auxiliary_loss = enable_auxiliary_loss
-        if self.backbone.layers == 18:
-            fpn_dim = 128
-            inplane_head = 512
-            fpn_inplanes = [64, 128, 256, 512]
-        else:
-            fpn_dim = 256
-            inplane_head = 2048
-            fpn_inplanes = [256, 512, 1024, 2048]
-
-        self.head = SFNetHead(
-            inplane=inplane_head,
-            num_class=num_classes,
-            fpn_inplanes=fpn_inplanes,
-            fpn_dim=fpn_dim,
-            enable_auxiliary_loss=self.enable_auxiliary_loss)
-        self.init_weight()
-
-    def forward(self, x):
-        feats = self.backbone(x)
-        feats = [feats[i] for i in self.backbone_indices]
-        logit_list = self.head(feats)
-        logit_list = [
-            F.interpolate(
-                logit,
-                x.shape[2:],
-                mode='bilinear',
-                align_corners=self.align_corners) for logit in logit_list
-        ]
-        return logit_list
-
-    def init_weight(self):
-        if self.pretrained is not None:
-            utils.load_entire_model(self, self.pretrained)
-
-
-class SFNetHead(nn.Layer):
-    """
-    The SFNetHead implementation.
-
-    Args:
-        inplane (int): Input channels of PPM module.
-        num_class (int): The unique number of target classes.
-        fpn_inplanes (list): The feature channels from backbone.
-        fpn_dim (int, optional): The input channels of FAM module. Default: 256.
-        enable_auxiliary_loss (bool, optional): A bool value indicates whether adding auxiliary loss. Default: False.
-    """
-
-    def __init__(self,
-                 inplane,
-                 num_class,
-                 fpn_inplanes,
-                 fpn_dim=256,
-                 enable_auxiliary_loss=False):
-        super(SFNetHead, self).__init__()
-        self.ppm = layers.PPModule(
-            in_channels=inplane,
-            out_channels=fpn_dim,
-            bin_sizes=(1, 2, 3, 6),
-            dim_reduction=True,
-            align_corners=True)
-        self.enable_auxiliary_loss = enable_auxiliary_loss
-        self.fpn_in = []
-
-        for fpn_inplane in fpn_inplanes[:-1]:
-            self.fpn_in.append(
-                nn.Sequential(
-                    nn.Conv2D(fpn_inplane, fpn_dim, 1),
-                    layers.SyncBatchNorm(fpn_dim), nn.ReLU()))
-
-        self.fpn_in = nn.LayerList(self.fpn_in)
-        self.fpn_out = []
-        self.fpn_out_align = []
-        self.dsn = []
-        for i in range(len(fpn_inplanes) - 1):
-            self.fpn_out.append(
-                nn.Sequential(
-                    layers.ConvBNReLU(
-                        fpn_dim, fpn_dim, 3, bias_attr=False)))
-            self.fpn_out_align.append(
-                AlignedModule(
-                    inplane=fpn_dim, outplane=fpn_dim // 2))
-            if self.enable_auxiliary_loss:
-                self.dsn.append(
-                    nn.Sequential(
-                        layers.AuxLayer(fpn_dim, fpn_dim, num_class)))
-
-        self.fpn_out = nn.LayerList(self.fpn_out)
-        self.fpn_out_align = nn.LayerList(self.fpn_out_align)
-
-        if self.enable_auxiliary_loss:
-            self.dsn = nn.LayerList(self.dsn)
-
-        self.conv_last = nn.Sequential(
-            layers.ConvBNReLU(
-                len(fpn_inplanes) * fpn_dim, fpn_dim, 3, bias_attr=False),
-            nn.Conv2D(
-                fpn_dim, num_class, kernel_size=1))
-
-    def forward(self, conv_out):
-        psp_out = self.ppm(conv_out[-1])
-        f = psp_out
-        fpn_feature_list = [psp_out]
-        out = []
-        for i in reversed(range(len(conv_out) - 1)):
-            conv_x = conv_out[i]
-            conv_x = self.fpn_in[i](conv_x)
-            f = self.fpn_out_align[i]([conv_x, f])
-            f = conv_x + f
-            fpn_feature_list.append(self.fpn_out[i](f))
-            if self.enable_auxiliary_loss:
-                out.append(self.dsn[i](f))
-
-        fpn_feature_list.reverse()
-        output_size = fpn_feature_list[0].shape[2:]
-        fusion_list = [fpn_feature_list[0]]
-
-        for i in range(1, len(fpn_feature_list)):
-            fusion_list.append(
-                F.interpolate(
-                    fpn_feature_list[i],
-                    output_size,
-                    mode='bilinear',
-                    align_corners=True))
-        fusion_out = paddle.concat(fusion_list, 1)
-        x = self.conv_last(fusion_out)
-        if self.enable_auxiliary_loss:
-            out.append(x)
-            return out
-        else:
-            return [x]
-
-
-class AlignedModule(nn.Layer):
-    """
-    The FAM module implementation.
-
-    Args:
-       inplane (int): Input channles of FAM module.
-       outplane (int): Output channels of FAN module.
-       kernel_size (int, optional): Kernel size of semantic flow convolution layer. Default: 3.
-    """
-
-    def __init__(self, inplane, outplane, kernel_size=3):
-        super(AlignedModule, self).__init__()
-        self.down_h = nn.Conv2D(inplane, outplane, 1, bias_attr=False)
-        self.down_l = nn.Conv2D(inplane, outplane, 1, bias_attr=False)
-        self.flow_make = nn.Conv2D(
-            outplane * 2,
-            2,
-            kernel_size=kernel_size,
-            padding=1,
-            bias_attr=False)
-
-    def flow_warp(self, inputs, flow, size):
-        out_h, out_w = size
-        n, c, h, w = inputs.shape
-        norm = paddle.to_tensor([[[[out_w, out_h]]]]).astype('float32')
-        h = paddle.linspace(-1.0, 1.0, out_h).reshape([-1, 1]).tile([1, out_w])
-        w = paddle.linspace(-1.0, 1.0, out_w).tile([out_h, 1])
-        grid = paddle.concat([paddle.unsqueeze(w, 2), paddle.unsqueeze(h, 2)],
-                             2)
-        grid = grid.tile([n, 1, 1, 1]).astype('float32')
-        grid = grid + flow.transpose([0, 2, 3, 1]) / norm
-        output = F.grid_sample(inputs, grid)
-        return output
-
-    def forward(self, x):
-        low_feature, h_feature = x
-        h_feature_orign = h_feature
-        h, w = low_feature.shape[2:]
-        size = (h, w)
-        low_feature = self.down_l(low_feature)
-        h_feature = self.down_h(h_feature)
-        h_feature = F.interpolate(
-            h_feature, size=size, mode='bilinear', align_corners=True)
-        flow = self.flow_make(paddle.concat([h_feature, low_feature], 1))
-        h_feature = self.flow_warp(h_feature_orign, flow, size=size)
-        return h_feature