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

paddlex/paddleseg/models/isanet.py

@@ -1,202 +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.models import layers
-from paddlex.paddleseg.cvlibs import manager
-from paddlex.paddleseg.utils import utils
-
-
-@manager.MODELS.add_component
-class ISANet(nn.Layer):
-    """Interlaced Sparse Self-Attention for Semantic Segmentation.
-
-    The original article refers to Lang Huang, et al. "Interlaced Sparse Self-Attention for Semantic Segmentation"
-    (https://arxiv.org/abs/1907.12273).
-
-    Args:
-        num_classes (int): The unique number of target classes.
-        backbone (Paddle.nn.Layer): A backbone network.
-        backbone_indices (tuple): The values in the tuple indicate the indices of output of backbone.
-        isa_channels (int): The channels of ISA Module.
-        down_factor (tuple): Divide the height and width dimension to (Ph, PW) groups.
-        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.  Default: False.
-        pretrained (str, optional): The path or url of pretrained model. Default: None.
-
-    """
-
-    def __init__(self,
-                 num_classes,
-                 backbone,
-                 backbone_indices=(2, 3),
-                 isa_channels=256,
-                 down_factor=(8, 8),
-                 enable_auxiliary_loss=True,
-                 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 = ISAHead(num_classes, in_channels, isa_channels,
-                            down_factor, enable_auxiliary_loss)
-        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)
-        logit_list = [
-            F.interpolate(
-                logit,
-                paddle.shape(x)[2:],
-                mode='bilinear',
-                align_corners=self.align_corners,
-                align_mode=1) 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 ISAHead(nn.Layer):
-    """
-    The ISAHead.
-
-    Args:
-        num_classes (int): The unique number of target classes.
-        in_channels (tuple): The number of input channels.
-        isa_channels (int): The channels of ISA Module.
-        down_factor (tuple): Divide the height and width dimension to (Ph, PW) groups.
-        enable_auxiliary_loss (bool, optional): A bool value indicates whether adding auxiliary loss. Default: True.
-    """
-
-    def __init__(self, num_classes, in_channels, isa_channels, down_factor,
-                 enable_auxiliary_loss):
-        super(ISAHead, self).__init__()
-        self.in_channels = in_channels[-1]
-        inter_channels = self.in_channels // 4
-        self.inter_channels = inter_channels
-        self.down_factor = down_factor
-        self.enable_auxiliary_loss = enable_auxiliary_loss
-        self.in_conv = layers.ConvBNReLU(
-            self.in_channels, inter_channels, 3, bias_attr=False)
-        self.global_relation = SelfAttentionBlock(inter_channels, isa_channels)
-        self.local_relation = SelfAttentionBlock(inter_channels, isa_channels)
-        self.out_conv = layers.ConvBNReLU(
-            inter_channels * 2, inter_channels, 1, bias_attr=False)
-        self.cls = nn.Sequential(
-            nn.Dropout2D(p=0.1), nn.Conv2D(inter_channels, num_classes, 1))
-        self.aux = nn.Sequential(
-            layers.ConvBNReLU(
-                in_channels=1024,
-                out_channels=256,
-                kernel_size=3,
-                bias_attr=False),
-            nn.Dropout2D(p=0.1),
-            nn.Conv2D(256, num_classes, 1))
-
-    def forward(self, feat_list):
-        C3, C4 = feat_list
-        x = self.in_conv(C4)
-        x_shape = paddle.shape(x)
-        P_h, P_w = self.down_factor
-        Q_h, Q_w = paddle.ceil(x_shape[2] / P_h).astype('int32'), paddle.ceil(
-            x_shape[3] / P_w).astype('int32')
-        pad_h, pad_w = (Q_h * P_h - x_shape[2]).astype('int32'), (
-            Q_w * P_w - x_shape[3]).astype('int32')
-        if pad_h > 0 or pad_w > 0:
-            padding = paddle.concat(
-                [
-                    pad_w // 2, pad_w - pad_w // 2, pad_h // 2,
-                    pad_h - pad_h // 2
-                ],
-                axis=0)
-            feat = F.pad(x, padding)
-        else:
-            feat = x
-
-        feat = feat.reshape([0, x_shape[1], Q_h, P_h, Q_w, P_w])
-        feat = feat.transpose(
-            [0, 3, 5, 1, 2, 4]).reshape([-1, self.inter_channels, Q_h, Q_w])
-        feat = self.global_relation(feat)
-
-        feat = feat.reshape([x_shape[0], P_h, P_w, x_shape[1], Q_h, Q_w])
-        feat = feat.transpose(
-            [0, 4, 5, 3, 1, 2]).reshape([-1, self.inter_channels, P_h, P_w])
-        feat = self.local_relation(feat)
-
-        feat = feat.reshape([x_shape[0], Q_h, Q_w, x_shape[1], P_h, P_w])
-        feat = feat.transpose([0, 3, 1, 4, 2, 5]).reshape(
-            [0, self.inter_channels, P_h * Q_h, P_w * Q_w])
-        if pad_h > 0 or pad_w > 0:
-            feat = paddle.slice(
-                feat,
-                axes=[2, 3],
-                starts=[pad_h // 2, pad_w // 2],
-                ends=[pad_h // 2 + x_shape[2], pad_w // 2 + x_shape[3]])
-
-        feat = self.out_conv(paddle.concat([feat, x], axis=1))
-        output = self.cls(feat)
-
-        if self.enable_auxiliary_loss:
-            auxout = self.aux(C3)
-            return [output, auxout]
-        else:
-            return [output]
-
-
-class SelfAttentionBlock(layers.AttentionBlock):
-    """General self-attention block/non-local block.
-
-       Args:
-            in_channels (int): Input channels of key/query feature.
-            channels (int): Output channels of key/query transform.
-    """
-
-    def __init__(self, in_channels, channels):
-        super(SelfAttentionBlock, self).__init__(
-            key_in_channels=in_channels,
-            query_in_channels=in_channels,
-            channels=channels,
-            out_channels=in_channels,
-            share_key_query=False,
-            query_downsample=None,
-            key_downsample=None,
-            key_query_num_convs=2,
-            key_query_norm=True,
-            value_out_num_convs=1,
-            value_out_norm=False,
-            matmul_norm=True,
-            with_out=False)
-
-        self.output_project = self.build_project(
-            in_channels, in_channels, num_convs=1, use_conv_module=True)
-
-    def forward(self, x):
-        context = super(SelfAttentionBlock, self).forward(x, x)
-        return self.output_project(context)

paddlex/paddleseg/models/layers/__init__.py

@@ -1,19 +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.
-
-from .layer_libs import ConvBNReLU, ConvBN, SeparableConvBNReLU, DepthwiseConvBN, AuxLayer, SyncBatchNorm
-from .activation import Activation
-from .pyramid_pool import ASPPModule, PPModule
-from .attention import AttentionBlock
-from .nonlocal2d import NonLocal2D

paddlex/paddleseg/models/layers/activation.py

@@ -1,73 +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
-
-
-class Activation(nn.Layer):
-    """
-    The wrapper of activations.
-
-    Args:
-        act (str, optional): The activation name in lowercase. It must be one of ['elu', 'gelu',
-            'hardshrink', 'tanh', 'hardtanh', 'prelu', 'relu', 'relu6', 'selu', 'leakyrelu', 'sigmoid',
-            'softmax', 'softplus', 'softshrink', 'softsign', 'tanhshrink', 'logsigmoid', 'logsoftmax',
-            'hsigmoid']. Default: None, means identical transformation.
-
-    Returns:
-        A callable object of Activation.
-
-    Raises:
-        KeyError: When parameter `act` is not in the optional range.
-
-    Examples:
-
-        from paddlex.paddleseg.models.common.activation import Activation
-
-        relu = Activation("relu")
-        print(relu)
-        # <class 'paddle.nn.layer.activation.ReLU'>
-
-        sigmoid = Activation("sigmoid")
-        print(sigmoid)
-        # <class 'paddle.nn.layer.activation.Sigmoid'>
-
-        not_exit_one = Activation("not_exit_one")
-        # KeyError: "not_exit_one does not exist in the current dict_keys(['elu', 'gelu', 'hardshrink',
-        # 'tanh', 'hardtanh', 'prelu', 'relu', 'relu6', 'selu', 'leakyrelu', 'sigmoid', 'softmax',
-        # 'softplus', 'softshrink', 'softsign', 'tanhshrink', 'logsigmoid', 'logsoftmax', 'hsigmoid'])"
-    """
-
-    def __init__(self, act=None):
-        super(Activation, self).__init__()
-
-        self._act = act
-        upper_act_names = nn.layer.activation.__dict__.keys()
-        lower_act_names = [act.lower() for act in upper_act_names]
-        act_dict = dict(zip(lower_act_names, upper_act_names))
-
-        if act is not None:
-            if act in act_dict.keys():
-                act_name = act_dict[act]
-                self.act_func = eval("nn.layer.activation.{}()".format(
-                    act_name))
-            else:
-                raise KeyError("{} does not exist in the current {}".format(
-                    act, act_dict.keys()))
-
-    def forward(self, x):
-        if self._act is not None:
-            return self.act_func(x)
-        else:
-            return x

paddlex/paddleseg/models/layers/attention.py

@@ -1,146 +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.models import layers
-
-
-class AttentionBlock(nn.Layer):
-    """General self-attention block/non-local block.
-
-    The original article refers to refer to https://arxiv.org/abs/1706.03762.
-    Args:
-        key_in_channels (int): Input channels of key feature.
-        query_in_channels (int): Input channels of query feature.
-        channels (int): Output channels of key/query transform.
-        out_channels (int): Output channels.
-        share_key_query (bool): Whether share projection weight between key
-            and query projection.
-        query_downsample (nn.Module): Query downsample module.
-        key_downsample (nn.Module): Key downsample module.
-        key_query_num_convs (int): Number of convs for key/query projection.
-        value_out_num_convs (int): Number of convs for value projection.
-        key_query_norm (bool): Whether to use BN for key/query projection.
-        value_out_norm (bool): Whether to use BN for value projection.
-        matmul_norm (bool): Whether normalize attention map with sqrt of
-            channels
-        with_out (bool): Whether use out projection.
-    """
-
-    def __init__(self, key_in_channels, query_in_channels, channels,
-                 out_channels, share_key_query, query_downsample,
-                 key_downsample, key_query_num_convs, value_out_num_convs,
-                 key_query_norm, value_out_norm, matmul_norm, with_out):
-        super(AttentionBlock, self).__init__()
-        if share_key_query:
-            assert key_in_channels == query_in_channels
-        self.with_out = with_out
-        self.key_in_channels = key_in_channels
-        self.query_in_channels = query_in_channels
-        self.out_channels = out_channels
-        self.channels = channels
-        self.share_key_query = share_key_query
-        self.key_project = self.build_project(
-            key_in_channels,
-            channels,
-            num_convs=key_query_num_convs,
-            use_conv_module=key_query_norm)
-        if share_key_query:
-            self.query_project = self.key_project
-        else:
-            self.query_project = self.build_project(
-                query_in_channels,
-                channels,
-                num_convs=key_query_num_convs,
-                use_conv_module=key_query_norm)
-
-        self.value_project = self.build_project(
-            key_in_channels,
-            channels if self.with_out else out_channels,
-            num_convs=value_out_num_convs,
-            use_conv_module=value_out_norm)
-
-        if self.with_out:
-            self.out_project = self.build_project(
-                channels,
-                out_channels,
-                num_convs=value_out_num_convs,
-                use_conv_module=value_out_norm)
-        else:
-            self.out_project = None
-
-        self.query_downsample = query_downsample
-        self.key_downsample = key_downsample
-        self.matmul_norm = matmul_norm
-
-    def build_project(self, in_channels, channels, num_convs, use_conv_module):
-        if use_conv_module:
-            convs = [
-                layers.ConvBNReLU(
-                    in_channels=in_channels,
-                    out_channels=channels,
-                    kernel_size=1,
-                    bias_attr=False)
-            ]
-            for _ in range(num_convs - 1):
-                convs.append(
-                    layers.ConvBNReLU(
-                        in_channels=channels,
-                        out_channels=channels,
-                        kernel_size=1,
-                        bias_attr=False))
-        else:
-            convs = [nn.Conv2D(in_channels, channels, 1)]
-            for _ in range(num_convs - 1):
-                convs.append(nn.Conv2D(channels, channels, 1))
-
-        if len(convs) > 1:
-            convs = nn.Sequential(*convs)
-        else:
-            convs = convs[0]
-        return convs
-
-    def forward(self, query_feats, key_feats):
-        query_shape = paddle.shape(query_feats)
-        query = self.query_project(query_feats)
-        if self.query_downsample is not None:
-            query = self.query_downsample(query)
-        query = query.flatten(2).transpose([0, 2, 1])
-
-        key = self.key_project(key_feats)
-        value = self.value_project(key_feats)
-
-        if self.key_downsample is not None:
-            key = self.key_downsample(key)
-            value = self.key_downsample(value)
-
-        key = key.flatten(2)
-        value = value.flatten(2).transpose([0, 2, 1])
-        sim_map = paddle.matmul(query, key)
-        if self.matmul_norm:
-            sim_map = (self.channels**-0.5) * sim_map
-        sim_map = F.softmax(sim_map, axis=-1)
-
-        context = paddle.matmul(sim_map, value)
-        context = paddle.transpose(context, [0, 2, 1])
-
-        context = paddle.reshape(
-            context, [0, self.out_channels, query_shape[2], query_shape[3]])
-
-        if self.out_project is not None:
-            context = self.out_project(context)
-        return context

paddlex/paddleseg/models/layers/layer_libs.py

@@ -1,168 +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 os
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-
-def SyncBatchNorm(*args, **kwargs):
-    """In cpu environment nn.SyncBatchNorm does not have kernel so use nn.BatchNorm2D instead"""
-    if paddle.get_device() == 'cpu' or os.environ.get(
-            'PADDLESEG_EXPORT_STAGE'):
-        return nn.BatchNorm2D(*args, **kwargs)
-    else:
-        return nn.SyncBatchNorm(*args, **kwargs)
-
-
-class ConvBNReLU(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 padding='same',
-                 **kwargs):
-        super().__init__()
-
-        self._conv = nn.Conv2D(
-            in_channels, out_channels, kernel_size, padding=padding, **kwargs)
-
-        self._batch_norm = SyncBatchNorm(out_channels)
-
-    def forward(self, x):
-        x = self._conv(x)
-        x = self._batch_norm(x)
-        x = F.relu(x)
-        return x
-
-
-class ConvBN(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 padding='same',
-                 **kwargs):
-        super().__init__()
-        self._conv = nn.Conv2D(
-            in_channels, out_channels, kernel_size, padding=padding, **kwargs)
-        self._batch_norm = SyncBatchNorm(out_channels)
-
-    def forward(self, x):
-        x = self._conv(x)
-        x = self._batch_norm(x)
-        return x
-
-
-class ConvReLUPool(nn.Layer):
-    def __init__(self, in_channels, out_channels):
-        super().__init__()
-        self.conv = nn.Conv2D(
-            in_channels,
-            out_channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            dilation=1)
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = F.relu(x)
-        x = F.pool2d(x, pool_size=2, pool_type="max", pool_stride=2)
-        return x
-
-
-class SeparableConvBNReLU(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 padding='same',
-                 **kwargs):
-        super().__init__()
-        self.depthwise_conv = ConvBN(
-            in_channels,
-            out_channels=in_channels,
-            kernel_size=kernel_size,
-            padding=padding,
-            groups=in_channels,
-            **kwargs)
-        self.piontwise_conv = ConvBNReLU(
-            in_channels, out_channels, kernel_size=1, groups=1)
-
-    def forward(self, x):
-        x = self.depthwise_conv(x)
-        x = self.piontwise_conv(x)
-        return x
-
-
-class DepthwiseConvBN(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 padding='same',
-                 **kwargs):
-        super().__init__()
-        self.depthwise_conv = ConvBN(
-            in_channels,
-            out_channels=out_channels,
-            kernel_size=kernel_size,
-            padding=padding,
-            groups=in_channels,
-            **kwargs)
-
-    def forward(self, x):
-        x = self.depthwise_conv(x)
-        return x
-
-
-class AuxLayer(nn.Layer):
-    """
-    The auxiliary layer implementation for auxiliary loss.
-
-    Args:
-        in_channels (int): The number of input channels.
-        inter_channels (int): The intermediate channels.
-        out_channels (int): The number of output channels, and usually it is num_classes.
-        dropout_prob (float, optional): The drop rate. Default: 0.1.
-    """
-
-    def __init__(self,
-                 in_channels,
-                 inter_channels,
-                 out_channels,
-                 dropout_prob=0.1):
-        super().__init__()
-
-        self.conv_bn_relu = ConvBNReLU(
-            in_channels=in_channels,
-            out_channels=inter_channels,
-            kernel_size=3,
-            padding=1)
-
-        self.dropout = nn.Dropout(p=dropout_prob)
-
-        self.conv = nn.Conv2D(
-            in_channels=inter_channels,
-            out_channels=out_channels,
-            kernel_size=1)
-
-    def forward(self, x):
-        x = self.conv_bn_relu(x)
-        x = self.dropout(x)
-        x = self.conv(x)
-        return x