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

paddlex/ppdet/modeling/reid/jde_embedding_head.py

@@ -1,189 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import math
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle import ParamAttr
-from paddle.regularizer import L2Decay
-from paddlex.ppdet.core.workspace import register
-from paddle.nn.initializer import Normal, Constant
-
-__all__ = ['JDEEmbeddingHead']
-
-
-class LossParam(nn.Layer):
-    def __init__(self, init_value=0., use_uncertainy=True):
-        super(LossParam, self).__init__()
-        self.loss_param = self.create_parameter(
-            shape=[1],
-            attr=ParamAttr(initializer=Constant(value=init_value)),
-            dtype="float32")
-
-    def forward(self, inputs):
-        out = paddle.exp(-self.loss_param) * inputs + self.loss_param
-        return out * 0.5
-
-
-@register
-class JDEEmbeddingHead(nn.Layer):
-    __shared__ = ['num_classes']
-    __inject__ = ['emb_loss', 'jde_loss']
-    """
-    JDEEmbeddingHead
-    Args:
-        num_classes(int): Number of classes. Only support one class tracking.
-        num_identifiers(int): Number of identifiers.
-        anchor_levels(int): Number of anchor levels, same as FPN levels.
-        anchor_scales(int): Number of anchor scales on each FPN level.
-        embedding_dim(int): Embedding dimension. Default: 512.
-        emb_loss(object): Instance of 'JDEEmbeddingLoss'
-        jde_loss(object): Instance of 'JDELoss'
-    """
-
-    def __init__(
-            self,
-            num_classes=1,
-            num_identifiers=1,  # defined by dataset.total_identities
-            anchor_levels=3,
-            anchor_scales=4,
-            embedding_dim=512,
-            emb_loss='JDEEmbeddingLoss',
-            jde_loss='JDELoss'):
-        super(JDEEmbeddingHead, self).__init__()
-        self.num_classes = num_classes
-        self.num_identifiers = num_identifiers
-        self.anchor_levels = anchor_levels
-        self.anchor_scales = anchor_scales
-        self.embedding_dim = embedding_dim
-        self.emb_loss = emb_loss
-        self.jde_loss = jde_loss
-
-        self.emb_scale = math.sqrt(2) * math.log(
-            self.num_identifiers - 1) if self.num_identifiers > 1 else 1
-
-        self.identify_outputs = []
-        self.loss_params_cls = []
-        self.loss_params_reg = []
-        self.loss_params_ide = []
-        for i in range(self.anchor_levels):
-            name = 'identify_output.{}'.format(i)
-            identify_output = self.add_sublayer(
-                name,
-                nn.Conv2D(
-                    in_channels=64 * (2**self.anchor_levels) // (2**i),
-                    out_channels=self.embedding_dim,
-                    kernel_size=3,
-                    stride=1,
-                    padding=1,
-                    weight_attr=ParamAttr(name=name + '.conv.weights'),
-                    bias_attr=ParamAttr(
-                        name=name + '.conv.bias', regularizer=L2Decay(0.))))
-            self.identify_outputs.append(identify_output)
-
-            loss_p_cls = self.add_sublayer('cls.{}'.format(i),
-                                           LossParam(-4.15))
-            self.loss_params_cls.append(loss_p_cls)
-            loss_p_reg = self.add_sublayer('reg.{}'.format(i),
-                                           LossParam(-4.85))
-            self.loss_params_reg.append(loss_p_reg)
-            loss_p_ide = self.add_sublayer('ide.{}'.format(i), LossParam(-2.3))
-            self.loss_params_ide.append(loss_p_ide)
-
-        self.classifier = self.add_sublayer(
-            'classifier',
-            nn.Linear(
-                self.embedding_dim,
-                self.num_identifiers,
-                weight_attr=ParamAttr(
-                    learning_rate=1., initializer=Normal(
-                        mean=0.0, std=0.01)),
-                bias_attr=ParamAttr(
-                    learning_rate=2., regularizer=L2Decay(0.))))
-
-    def forward(self,
-                identify_feats,
-                targets=None,
-                loss_confs=None,
-                loss_boxes=None,
-                test_emb=False):
-        assert len(identify_feats) == self.anchor_levels
-        ide_outs = []
-        for feat, ide_head in zip(identify_feats, self.identify_outputs):
-            ide_outs.append(ide_head(feat))
-
-        if self.training:
-            assert targets != None
-            assert len(loss_confs) == len(loss_boxes) == self.anchor_levels
-            loss_ides = self.emb_loss(ide_outs, targets, self.emb_scale,
-                                      self.classifier)
-            return self.jde_loss(loss_confs, loss_boxes, loss_ides,
-                                 self.loss_params_cls, self.loss_params_reg,
-                                 self.loss_params_ide, targets)
-        else:
-            if test_emb:
-                assert targets != None
-                embs_and_gts = self.get_emb_and_gt_outs(ide_outs, targets)
-                return embs_and_gts
-            else:
-                emb_outs = self.get_emb_outs(ide_outs)
-                return emb_outs
-
-    def get_emb_and_gt_outs(self, ide_outs, targets):
-        emb_and_gts = []
-        for i, p_ide in enumerate(ide_outs):
-            t_conf = targets['tconf{}'.format(i)]
-            t_ide = targets['tide{}'.format(i)]
-
-            p_ide = p_ide.transpose((0, 2, 3, 1))
-            p_ide_flatten = paddle.reshape(p_ide, [-1, self.embedding_dim])
-
-            mask = t_conf > 0
-            mask = paddle.cast(mask, dtype="int64")
-            emb_mask = mask.max(1).flatten()
-            emb_mask_inds = paddle.nonzero(emb_mask > 0).flatten()
-            if len(emb_mask_inds) > 0:
-                t_ide_flatten = paddle.reshape(t_ide.max(1), [-1, 1])
-                tids = paddle.gather(t_ide_flatten, emb_mask_inds)
-
-                embedding = paddle.gather(p_ide_flatten, emb_mask_inds)
-                embedding = self.emb_scale * F.normalize(embedding)
-                emb_and_gt = paddle.concat([embedding, tids], axis=1)
-                emb_and_gts.append(emb_and_gt)
-
-        if len(emb_and_gts) > 0:
-            return paddle.concat(emb_and_gts, axis=0)
-        else:
-            return paddle.zeros((1, self.embedding_dim + 1))
-
-    def get_emb_outs(self, ide_outs):
-        emb_outs = []
-        for i, p_ide in enumerate(ide_outs):
-            p_ide = p_ide.transpose((0, 2, 3, 1))
-
-            p_ide_repeat = paddle.tile(
-                p_ide.unsqueeze(axis=0), [1, self.anchor_scales, 1, 1, 1])
-            embedding = F.normalize(p_ide_repeat, axis=-1)
-            emb = paddle.reshape(embedding, [-1, self.embedding_dim])
-            emb_outs.append(emb)
-
-        if len(emb_outs) > 0:
-            return paddle.concat(emb_outs, axis=0)
-        else:
-            return paddle.zeros((1, self.embedding_dim))

paddlex/ppdet/modeling/reid/pyramidal_embedding.py

@@ -1,151 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle.nn.initializer import Normal, Constant
-from paddle import ParamAttr
-from .resnet import *
-from paddlex.ppdet.core.workspace import register
-
-__all__ = ['PCBPyramid']
-
-
-@register
-class PCBPyramid(nn.Layer):
-    """
-    PCB (Part-based Convolutional Baseline), see https://arxiv.org/abs/1711.09349,
-    Pyramidal Person Re-IDentification, see https://arxiv.org/abs/1810.12193
-
-    Args:
-        input_ch (int): Number of channels of the input feature.
-        num_stripes (int): Number of sub-parts.
-        used_levels (tuple): Whether the level is used, 1 means used.
-        num_classes (int): Number of classes for identities.
-        last_conv_stride (int): Stride of the last conv.
-        last_conv_dilation (int): Dilation of the last conv.
-        num_conv_out_channels (int): Number of channels of conv feature.
-    """
-
-    def __init__(self,
-                 input_ch=2048,
-                 num_stripes=6,
-                 used_levels=(1, 1, 1, 1, 1, 1),
-                 num_classes=751,
-                 last_conv_stride=1,
-                 last_conv_dilation=1,
-                 num_conv_out_channels=128):
-        super(PCBPyramid, self).__init__()
-        self.num_stripes = num_stripes
-        self.used_levels = used_levels
-        self.num_classes = num_classes
-
-        self.num_in_each_level = [i for i in range(self.num_stripes, 0, -1)]
-        self.num_branches = sum(self.num_in_each_level)
-
-        self.base = ResNet101(
-            lr_mult=0.1,
-            last_conv_stride=last_conv_stride,
-            last_conv_dilation=last_conv_dilation)
-        self.dropout_layer = nn.Dropout(p=0.2)
-        self.pyramid_conv_list0, self.pyramid_fc_list0 = self.basic_branch(
-            num_conv_out_channels, input_ch)
-
-    def basic_branch(self, num_conv_out_channels, input_ch):
-        # the level indexes are defined from fine to coarse,
-        # the branch will contain one more part than that of its previous level
-        # the sliding step is set to 1
-        pyramid_conv_list = nn.LayerList()
-        pyramid_fc_list = nn.LayerList()
-
-        idx_levels = 0
-        for idx_branches in range(self.num_branches):
-            if idx_branches >= sum(self.num_in_each_level[0:idx_levels + 1]):
-                idx_levels += 1
-            if self.used_levels[idx_levels] == 0:
-                continue
-            pyramid_conv_list.append(
-                nn.Sequential(
-                    nn.Conv2D(input_ch, num_conv_out_channels, 1),
-                    nn.BatchNorm2D(num_conv_out_channels), nn.ReLU()))
-
-        idx_levels = 0
-        for idx_branches in range(self.num_branches):
-            if idx_branches >= sum(self.num_in_each_level[0:idx_levels + 1]):
-                idx_levels += 1
-            if self.used_levels[idx_levels] == 0:
-                continue
-            name = "Linear_branch_id_{}".format(idx_branches)
-            fc = nn.Linear(
-                in_features=num_conv_out_channels,
-                out_features=self.num_classes,
-                weight_attr=ParamAttr(
-                    name=name + "_weights",
-                    initializer=Normal(
-                        mean=0., std=0.001)),
-                bias_attr=ParamAttr(
-                    name=name + "_bias", initializer=Constant(value=0.)))
-            pyramid_fc_list.append(fc)
-        return pyramid_conv_list, pyramid_fc_list
-
-    def pyramid_forward(self, feat):
-        each_stripe_size = int(feat.shape[2] / self.num_stripes)
-
-        feat_list, logits_list = [], []
-        idx_levels = 0
-        used_branches = 0
-        for idx_branches in range(self.num_branches):
-            if idx_branches >= sum(self.num_in_each_level[0:idx_levels + 1]):
-                idx_levels += 1
-            if self.used_levels[idx_levels] == 0:
-                continue
-            idx_in_each_level = idx_branches - sum(self.num_in_each_level[
-                0:idx_levels])
-            stripe_size_in_each_level = each_stripe_size * (idx_levels + 1)
-            start = idx_in_each_level * each_stripe_size
-            end = start + stripe_size_in_each_level
-
-            k = feat.shape[-1]
-            local_feat_avgpool = F.avg_pool2d(
-                feat[:, :, start:end, :],
-                kernel_size=(stripe_size_in_each_level, k))
-            local_feat_maxpool = F.max_pool2d(
-                feat[:, :, start:end, :],
-                kernel_size=(stripe_size_in_each_level, k))
-            local_feat = local_feat_avgpool + local_feat_maxpool
-
-            local_feat = self.pyramid_conv_list0[used_branches](local_feat)
-            local_feat = paddle.reshape(
-                local_feat, shape=[local_feat.shape[0], -1])
-            feat_list.append(local_feat)
-
-            local_logits = self.pyramid_fc_list0[used_branches](
-                self.dropout_layer(local_feat))
-            logits_list.append(local_logits)
-
-            used_branches += 1
-
-        return feat_list, logits_list
-
-    def forward(self, x):
-        feat = self.base(x)
-        assert feat.shape[2] % self.num_stripes == 0
-        feat_list, logits_list = self.pyramid_forward(feat)
-        feat_out = paddle.concat(feat_list, axis=-1)
-        return feat_out

paddlex/ppdet/modeling/reid/resnet.py

@@ -1,320 +0,0 @@
-# copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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 __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import math
-import paddle
-from paddle import ParamAttr
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle.nn.initializer import Normal
-
-__all__ = ["ResNet18", "ResNet34", "ResNet50", "ResNet101", "ResNet152"]
-
-
-class ConvBNLayer(nn.Layer):
-    def __init__(self,
-                 num_channels,
-                 num_filters,
-                 filter_size,
-                 stride=1,
-                 dilation=1,
-                 groups=1,
-                 act=None,
-                 lr_mult=1.0,
-                 name=None,
-                 data_format="NCHW"):
-        super(ConvBNLayer, self).__init__()
-        conv_stdv = filter_size * filter_size * num_filters
-        self._conv = nn.Conv2D(
-            in_channels=num_channels,
-            out_channels=num_filters,
-            kernel_size=filter_size,
-            stride=stride,
-            padding=(filter_size - 1) // 2,
-            dilation=dilation,
-            groups=groups,
-            weight_attr=ParamAttr(
-                name=name + "_weights",
-                learning_rate=lr_mult,
-                initializer=Normal(0, math.sqrt(2. / conv_stdv))),
-            bias_attr=False,
-            data_format=data_format)
-        if name == "conv1":
-            bn_name = "bn_" + name
-        else:
-            bn_name = "bn" + name[3:]
-        self._batch_norm = nn.BatchNorm(
-            num_filters,
-            act=act,
-            param_attr=ParamAttr(name=bn_name + "_scale"),
-            bias_attr=ParamAttr(bn_name + "_offset"),
-            moving_mean_name=bn_name + "_mean",
-            moving_variance_name=bn_name + "_variance",
-            data_layout=data_format)
-
-    def forward(self, inputs):
-        y = self._conv(inputs)
-        y = self._batch_norm(y)
-        return y
-
-
-class BottleneckBlock(nn.Layer):
-    def __init__(self,
-                 num_channels,
-                 num_filters,
-                 stride,
-                 shortcut=True,
-                 name=None,
-                 lr_mult=1.0,
-                 dilation=1,
-                 data_format="NCHW"):
-        super(BottleneckBlock, self).__init__()
-        self.conv0 = ConvBNLayer(
-            num_channels=num_channels,
-            num_filters=num_filters,
-            filter_size=1,
-            dilation=dilation,
-            act="relu",
-            lr_mult=lr_mult,
-            name=name + "_branch2a",
-            data_format=data_format)
-        self.conv1 = ConvBNLayer(
-            num_channels=num_filters,
-            num_filters=num_filters,
-            filter_size=3,
-            dilation=dilation,
-            stride=stride,
-            act="relu",
-            lr_mult=lr_mult,
-            name=name + "_branch2b",
-            data_format=data_format)
-        self.conv2 = ConvBNLayer(
-            num_channels=num_filters,
-            num_filters=num_filters * 4,
-            filter_size=1,
-            dilation=dilation,
-            act=None,
-            lr_mult=lr_mult,
-            name=name + "_branch2c",
-            data_format=data_format)
-        if not shortcut:
-            self.short = ConvBNLayer(
-                num_channels=num_channels,
-                num_filters=num_filters * 4,
-                filter_size=1,
-                dilation=dilation,
-                stride=stride,
-                lr_mult=lr_mult,
-                name=name + "_branch1",
-                data_format=data_format)
-        self.shortcut = shortcut
-        self._num_channels_out = num_filters * 4
-
-    def forward(self, inputs):
-        y = self.conv0(inputs)
-        conv1 = self.conv1(y)
-        conv2 = self.conv2(conv1)
-        if self.shortcut:
-            short = inputs
-        else:
-            short = self.short(inputs)
-        y = paddle.add(x=short, y=conv2)
-        y = F.relu(y)
-        return y
-
-
-class BasicBlock(nn.Layer):
-    def __init__(self,
-                 num_channels,
-                 num_filters,
-                 stride,
-                 shortcut=True,
-                 name=None,
-                 data_format="NCHW"):
-        super(BasicBlock, self).__init__()
-        self.stride = stride
-        self.conv0 = ConvBNLayer(
-            num_channels=num_channels,
-            num_filters=num_filters,
-            filter_size=3,
-            stride=stride,
-            act="relu",
-            name=name + "_branch2a",
-            data_format=data_format)
-        self.conv1 = ConvBNLayer(
-            num_channels=num_filters,
-            num_filters=num_filters,
-            filter_size=3,
-            act=None,
-            name=name + "_branch2b",
-            data_format=data_format)
-        if not shortcut:
-            self.short = ConvBNLayer(
-                num_channels=num_channels,
-                num_filters=num_filters,
-                filter_size=1,
-                stride=stride,
-                name=name + "_branch1",
-                data_format=data_format)
-        self.shortcut = shortcut
-
-    def forward(self, inputs):
-        y = self.conv0(inputs)
-        conv1 = self.conv1(y)
-        if self.shortcut:
-            short = inputs
-        else:
-            short = self.short(inputs)
-        y = paddle.add(x=short, y=conv1)
-        y = F.relu(y)
-        return y
-
-
-class ResNet(nn.Layer):
-    def __init__(self,
-                 layers=50,
-                 lr_mult=1.0,
-                 last_conv_stride=2,
-                 last_conv_dilation=1):
-        super(ResNet, self).__init__()
-        self.layers = layers
-        self.data_format = "NCHW"
-        self.input_image_channel = 3
-        supported_layers = [18, 34, 50, 101, 152]
-        assert layers in supported_layers, \
-            "supported layers are {} but input layer is {}".format(
-                supported_layers, layers)
-        if layers == 18:
-            depth = [2, 2, 2, 2]
-        elif layers == 34 or layers == 50:
-            depth = [3, 4, 6, 3]
-        elif layers == 101:
-            depth = [3, 4, 23, 3]
-        elif layers == 152:
-            depth = [3, 8, 36, 3]
-        num_channels = [64, 256, 512,
-                        1024] if layers >= 50 else [64, 64, 128, 256]
-        num_filters = [64, 128, 256, 512]
-        self.conv = ConvBNLayer(
-            num_channels=self.input_image_channel,
-            num_filters=64,
-            filter_size=7,
-            stride=2,
-            act="relu",
-            lr_mult=lr_mult,
-            name="conv1",
-            data_format=self.data_format)
-        self.pool2d_max = nn.MaxPool2D(
-            kernel_size=3, stride=2, padding=1, data_format=self.data_format)
-        self.block_list = []
-        if layers >= 50:
-            for block in range(len(depth)):
-                shortcut = False
-                for i in range(depth[block]):
-                    if layers in [101, 152] and block == 2:
-                        if i == 0:
-                            conv_name = "res" + str(block + 2) + "a"
-                        else:
-                            conv_name = "res" + str(block + 2) + "b" + str(i)
-                    else:
-                        conv_name = "res" + str(block + 2) + chr(97 + i)
-                    if i != 0 or block == 0:
-                        stride = 1
-                    elif block == len(depth) - 1:
-                        stride = last_conv_stride
-                    else:
-                        stride = 2
-                    bottleneck_block = self.add_sublayer(
-                        conv_name,
-                        BottleneckBlock(
-                            num_channels=num_channels[block]
-                            if i == 0 else num_filters[block] * 4,
-                            num_filters=num_filters[block],
-                            stride=stride,
-                            shortcut=shortcut,
-                            name=conv_name,
-                            lr_mult=lr_mult,
-                            dilation=last_conv_dilation
-                            if block == len(depth) - 1 else 1,
-                            data_format=self.data_format))
-                    self.block_list.append(bottleneck_block)
-                    shortcut = True
-        else:
-            for block in range(len(depth)):
-                shortcut = False
-                for i in range(depth[block]):
-                    conv_name = "res" + str(block + 2) + chr(97 + i)
-                    basic_block = self.add_sublayer(
-                        conv_name,
-                        BasicBlock(
-                            num_channels=num_channels[block]
-                            if i == 0 else num_filters[block],
-                            num_filters=num_filters[block],
-                            stride=2 if i == 0 and block != 0 else 1,
-                            shortcut=shortcut,
-                            name=conv_name,
-                            data_format=self.data_format))
-                    self.block_list.append(basic_block)
-                    shortcut = True
-
-    def forward(self, inputs):
-        y = self.conv(inputs)
-        y = self.pool2d_max(y)
-        for block in self.block_list:
-            y = block(y)
-        return y
-
-
-def ResNet18(**args):
-    model = ResNet(layers=18, **args)
-    return model
-
-
-def ResNet34(**args):
-    model = ResNet(layers=34, **args)
-    return model
-
-
-def ResNet50(pretrained=None, **args):
-    model = ResNet(layers=50, **args)
-    if pretrained is not None:
-        if not (os.path.isdir(pretrained) or
-                os.path.exists(pretrained + '.pdparams')):
-            raise ValueError("Model pretrain path {} does not "
-                             "exists.".format(pretrained))
-        param_state_dict = paddle.load(pretrained + '.pdparams')
-        model.set_dict(param_state_dict)
-    return model
-
-
-def ResNet101(pretrained=None, **args):
-    model = ResNet(layers=101, **args)
-    if pretrained is not None:
-        if not (os.path.isdir(pretrained) or
-                os.path.exists(pretrained + '.pdparams')):
-            raise ValueError("Model pretrain path {} does not "
-                             "exists.".format(pretrained))
-        param_state_dict = paddle.load(pretrained + '.pdparams')
-        model.set_dict(param_state_dict)
-    return model
-
-
-def ResNet152(**args):
-    model = ResNet(layers=152, **args)
-    return model

paddlex/ppdet/modeling/shape_spec.py

@@ -1,33 +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 collections import namedtuple
-
-
-class ShapeSpec(
-        namedtuple("_ShapeSpec", ["channels", "height", "width", "stride"])):
-    """
-    A simple structure that contains basic shape specification about a tensor.
-    It is often used as the auxiliary inputs/outputs of models,
-    to complement the lack of shape inference ability among paddle modules.
-    Attributes:
-        channels:
-        height:
-        width:
-        stride:
-    """
-
-    def __new__(cls, channels=None, height=None, width=None, stride=None):
-        return super(ShapeSpec, cls).__new__(cls, channels, height, width,
-                                             stride)