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

paddlex/ppdet/modeling/heads/centernet_head.py

@@ -1,194 +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 numpy as np
-import math
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle import ParamAttr
-from paddle.nn.initializer import KaimingUniform
-from paddlex.ppdet.core.workspace import register
-from paddlex.ppdet.modeling.losses import CTFocalLoss
-
-
-class ConvLayer(nn.Layer):
-    def __init__(self,
-                 ch_in,
-                 ch_out,
-                 kernel_size,
-                 stride=1,
-                 padding=0,
-                 dilation=1,
-                 groups=1,
-                 bias=False):
-        super(ConvLayer, self).__init__()
-        bias_attr = False
-        fan_in = ch_in * kernel_size**2
-        bound = 1 / math.sqrt(fan_in)
-        param_attr = paddle.ParamAttr(initializer=KaimingUniform())
-        if bias:
-            bias_attr = paddle.ParamAttr(
-                initializer=nn.initializer.Uniform(-bound, bound))
-        self.conv = nn.Conv2D(
-            in_channels=ch_in,
-            out_channels=ch_out,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            groups=groups,
-            weight_attr=param_attr,
-            bias_attr=bias_attr)
-
-    def forward(self, inputs):
-        out = self.conv(inputs)
-
-        return out
-
-
-@register
-class CenterNetHead(nn.Layer):
-    """
-    Args:
-        in_channels (int): the channel number of input to CenterNetHead.
-        num_classes (int): the number of classes, 80 by default.
-        head_planes (int): the channel number in all head, 256 by default.
-        heatmap_weight (float): the weight of heatmap loss, 1 by default.
-        regress_ltrb (bool): whether to regress left/top/right/bottom or
-            width/height for a box, true by default
-        size_weight (float): the weight of box size loss, 0.1 by default.
-        offset_weight (float): the weight of center offset loss, 1 by default.
-
-    """
-
-    __shared__ = ['num_classes']
-
-    def __init__(self,
-                 in_channels,
-                 num_classes=80,
-                 head_planes=256,
-                 heatmap_weight=1,
-                 regress_ltrb=True,
-                 size_weight=0.1,
-                 offset_weight=1):
-        super(CenterNetHead, self).__init__()
-        self.weights = {
-            'heatmap': heatmap_weight,
-            'size': size_weight,
-            'offset': offset_weight
-        }
-        self.heatmap = nn.Sequential(
-            ConvLayer(
-                in_channels, head_planes, kernel_size=3, padding=1, bias=True),
-            nn.ReLU(),
-            ConvLayer(
-                head_planes,
-                num_classes,
-                kernel_size=1,
-                stride=1,
-                padding=0,
-                bias=True))
-        self.heatmap[2].conv.bias[:] = -2.19
-        self.size = nn.Sequential(
-            ConvLayer(
-                in_channels, head_planes, kernel_size=3, padding=1, bias=True),
-            nn.ReLU(),
-            ConvLayer(
-                head_planes,
-                4 if regress_ltrb else 2,
-                kernel_size=1,
-                stride=1,
-                padding=0,
-                bias=True))
-        self.offset = nn.Sequential(
-            ConvLayer(
-                in_channels, head_planes, kernel_size=3, padding=1, bias=True),
-            nn.ReLU(),
-            ConvLayer(
-                head_planes, 2, kernel_size=1, stride=1, padding=0, bias=True))
-        self.focal_loss = CTFocalLoss()
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        if isinstance(input_shape, (list, tuple)):
-            input_shape = input_shape[0]
-        return {'in_channels': input_shape.channels}
-
-    def forward(self, feat, inputs):
-        heatmap = self.heatmap(feat)
-        size = self.size(feat)
-        offset = self.offset(feat)
-        if self.training:
-            loss = self.get_loss(heatmap, size, offset, self.weights, inputs)
-            return loss
-        else:
-            heatmap = F.sigmoid(heatmap)
-            return {'heatmap': heatmap, 'size': size, 'offset': offset}
-
-    def get_loss(self, heatmap, size, offset, weights, inputs):
-        heatmap_target = inputs['heatmap']
-        size_target = inputs['size']
-        offset_target = inputs['offset']
-        index = inputs['index']
-        mask = inputs['index_mask']
-        heatmap = paddle.clip(F.sigmoid(heatmap), 1e-4, 1 - 1e-4)
-        heatmap_loss = self.focal_loss(heatmap, heatmap_target)
-
-        size = paddle.transpose(size, perm=[0, 2, 3, 1])
-        size_n, size_h, size_w, size_c = size.shape
-        size = paddle.reshape(size, shape=[size_n, -1, size_c])
-        index = paddle.unsqueeze(index, 2)
-        batch_inds = list()
-        for i in range(size_n):
-            batch_ind = paddle.full(
-                shape=[1, index.shape[1], 1], fill_value=i, dtype='int64')
-            batch_inds.append(batch_ind)
-        batch_inds = paddle.concat(batch_inds, axis=0)
-        index = paddle.concat(x=[batch_inds, index], axis=2)
-        pos_size = paddle.gather_nd(size, index=index)
-        mask = paddle.unsqueeze(mask, axis=2)
-        size_mask = paddle.expand_as(mask, pos_size)
-        size_mask = paddle.cast(size_mask, dtype=pos_size.dtype)
-        pos_num = size_mask.sum()
-        size_mask.stop_gradient = True
-        size_target.stop_gradient = True
-        size_loss = F.l1_loss(
-            pos_size * size_mask, size_target * size_mask, reduction='sum')
-        size_loss = size_loss / (pos_num + 1e-4)
-
-        offset = paddle.transpose(offset, perm=[0, 2, 3, 1])
-        offset_n, offset_h, offset_w, offset_c = offset.shape
-        offset = paddle.reshape(offset, shape=[offset_n, -1, offset_c])
-        pos_offset = paddle.gather_nd(offset, index=index)
-        offset_mask = paddle.expand_as(mask, pos_offset)
-        offset_mask = paddle.cast(offset_mask, dtype=pos_offset.dtype)
-        pos_num = offset_mask.sum()
-        offset_mask.stop_gradient = True
-        offset_target.stop_gradient = True
-        offset_loss = F.l1_loss(
-            pos_offset * offset_mask,
-            offset_target * offset_mask,
-            reduction='sum')
-        offset_loss = offset_loss / (pos_num + 1e-4)
-
-        det_loss = weights['heatmap'] * heatmap_loss + weights[
-            'size'] * size_loss + weights['offset'] * offset_loss
-
-        return {
-            'det_loss': det_loss,
-            'heatmap_loss': heatmap_loss,
-            'size_loss': size_loss,
-            'offset_loss': offset_loss
-        }

paddlex/ppdet/modeling/heads/face_head.py

@@ -1,113 +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.ppdet.core.workspace import register
-from paddle.regularizer import L2Decay
-from paddle import ParamAttr
-
-from ..layers import AnchorGeneratorSSD
-
-
-@register
-class FaceHead(nn.Layer):
-    """
-    Head block for Face detection network
-
-    Args:
-        num_classes (int): Number of output classes.
-        in_channels (int): Number of input channels.
-        anchor_generator(object): instance of anchor genertor method.
-        kernel_size (int): kernel size of Conv2D in FaceHead.
-        padding (int): padding of Conv2D in FaceHead.
-        conv_decay (float): norm_decay (float): weight decay for conv layer weights.
-        loss (object): loss of face detection model.
-    """
-    __shared__ = ['num_classes']
-    __inject__ = ['anchor_generator', 'loss']
-
-    def __init__(self,
-                 num_classes=80,
-                 in_channels=(96, 96),
-                 anchor_generator=AnchorGeneratorSSD().__dict__,
-                 kernel_size=3,
-                 padding=1,
-                 conv_decay=0.,
-                 loss='SSDLoss'):
-        super(FaceHead, self).__init__()
-        # add background class
-        self.num_classes = num_classes + 1
-        self.in_channels = in_channels
-        self.anchor_generator = anchor_generator
-        self.loss = loss
-
-        if isinstance(anchor_generator, dict):
-            self.anchor_generator = AnchorGeneratorSSD(**anchor_generator)
-
-        self.num_priors = self.anchor_generator.num_priors
-        self.box_convs = []
-        self.score_convs = []
-        for i, num_prior in enumerate(self.num_priors):
-            box_conv_name = "boxes{}".format(i)
-            box_conv = self.add_sublayer(
-                box_conv_name,
-                nn.Conv2D(
-                    in_channels=in_channels[i],
-                    out_channels=num_prior * 4,
-                    kernel_size=kernel_size,
-                    padding=padding))
-            self.box_convs.append(box_conv)
-
-            score_conv_name = "scores{}".format(i)
-            score_conv = self.add_sublayer(
-                score_conv_name,
-                nn.Conv2D(
-                    in_channels=in_channels[i],
-                    out_channels=num_prior * self.num_classes,
-                    kernel_size=kernel_size,
-                    padding=padding))
-            self.score_convs.append(score_conv)
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        return {'in_channels': [i.channels for i in input_shape], }
-
-    def forward(self, feats, image, gt_bbox=None, gt_class=None):
-        box_preds = []
-        cls_scores = []
-        prior_boxes = []
-        for feat, box_conv, score_conv in zip(feats, self.box_convs,
-                                              self.score_convs):
-            box_pred = box_conv(feat)
-            box_pred = paddle.transpose(box_pred, [0, 2, 3, 1])
-            box_pred = paddle.reshape(box_pred, [0, -1, 4])
-            box_preds.append(box_pred)
-
-            cls_score = score_conv(feat)
-            cls_score = paddle.transpose(cls_score, [0, 2, 3, 1])
-            cls_score = paddle.reshape(cls_score, [0, -1, self.num_classes])
-            cls_scores.append(cls_score)
-
-        prior_boxes = self.anchor_generator(feats, image)
-
-        if self.training:
-            return self.get_loss(box_preds, cls_scores, gt_bbox, gt_class,
-                                 prior_boxes)
-        else:
-            return (box_preds, cls_scores), prior_boxes
-
-    def get_loss(self, boxes, scores, gt_bbox, gt_class, prior_boxes):
-        return self.loss(boxes, scores, gt_bbox, gt_class, prior_boxes)

paddlex/ppdet/modeling/heads/fcos_head.py

@@ -1,270 +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 __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.nn.initializer import Normal, Constant
-
-from paddlex.ppdet.core.workspace import register
-from paddlex.ppdet.modeling.layers import ConvNormLayer
-
-
-class ScaleReg(nn.Layer):
-    """
-    Parameter for scaling the regression outputs.
-    """
-
-    def __init__(self):
-        super(ScaleReg, self).__init__()
-        self.scale_reg = self.create_parameter(
-            shape=[1],
-            attr=ParamAttr(initializer=Constant(value=1.)),
-            dtype="float32")
-
-    def forward(self, inputs):
-        out = inputs * self.scale_reg
-        return out
-
-
-@register
-class FCOSFeat(nn.Layer):
-    """
-    FCOSFeat of FCOS
-
-    Args:
-        feat_in (int): The channel number of input Tensor.
-        feat_out (int): The channel number of output Tensor.
-        num_convs (int): The convolution number of the FCOSFeat.
-        norm_type (str): Normalization type, 'bn'/'sync_bn'/'gn'.
-        use_dcn (bool): Whether to use dcn in tower or not.
-    """
-
-    def __init__(self,
-                 feat_in=256,
-                 feat_out=256,
-                 num_convs=4,
-                 norm_type='bn',
-                 use_dcn=False):
-        super(FCOSFeat, self).__init__()
-        self.num_convs = num_convs
-        self.norm_type = norm_type
-        self.cls_subnet_convs = []
-        self.reg_subnet_convs = []
-        for i in range(self.num_convs):
-            in_c = feat_in if i == 0 else feat_out
-
-            cls_conv_name = 'fcos_head_cls_tower_conv_{}'.format(i)
-            cls_conv = self.add_sublayer(
-                cls_conv_name,
-                ConvNormLayer(
-                    ch_in=in_c,
-                    ch_out=feat_out,
-                    filter_size=3,
-                    stride=1,
-                    norm_type=norm_type,
-                    use_dcn=use_dcn,
-                    bias_on=True,
-                    lr_scale=2.))
-            self.cls_subnet_convs.append(cls_conv)
-
-            reg_conv_name = 'fcos_head_reg_tower_conv_{}'.format(i)
-            reg_conv = self.add_sublayer(
-                reg_conv_name,
-                ConvNormLayer(
-                    ch_in=in_c,
-                    ch_out=feat_out,
-                    filter_size=3,
-                    stride=1,
-                    norm_type=norm_type,
-                    use_dcn=use_dcn,
-                    bias_on=True,
-                    lr_scale=2.))
-            self.reg_subnet_convs.append(reg_conv)
-
-    def forward(self, fpn_feat):
-        cls_feat = fpn_feat
-        reg_feat = fpn_feat
-        for i in range(self.num_convs):
-            cls_feat = F.relu(self.cls_subnet_convs[i](cls_feat))
-            reg_feat = F.relu(self.reg_subnet_convs[i](reg_feat))
-        return cls_feat, reg_feat
-
-
-@register
-class FCOSHead(nn.Layer):
-    """
-    FCOSHead
-    Args:
-        fcos_feat (object): Instance of 'FCOSFeat'
-        num_classes (int): Number of classes
-        fpn_stride (list): The stride of each FPN Layer
-        prior_prob (float): Used to set the bias init for the class prediction layer
-        fcos_loss (object): Instance of 'FCOSLoss'
-        norm_reg_targets (bool): Normalization the regression target if true
-        centerness_on_reg (bool): The prediction of centerness on regression or clssification branch
-    """
-    __inject__ = ['fcos_feat', 'fcos_loss']
-    __shared__ = ['num_classes']
-
-    def __init__(self,
-                 fcos_feat,
-                 num_classes=80,
-                 fpn_stride=[8, 16, 32, 64, 128],
-                 prior_prob=0.01,
-                 fcos_loss='FCOSLoss',
-                 norm_reg_targets=True,
-                 centerness_on_reg=True):
-        super(FCOSHead, self).__init__()
-        self.fcos_feat = fcos_feat
-        self.num_classes = num_classes
-        self.fpn_stride = fpn_stride
-        self.prior_prob = prior_prob
-        self.fcos_loss = fcos_loss
-        self.norm_reg_targets = norm_reg_targets
-        self.centerness_on_reg = centerness_on_reg
-
-        conv_cls_name = "fcos_head_cls"
-        bias_init_value = -math.log((1 - self.prior_prob) / self.prior_prob)
-        self.fcos_head_cls = self.add_sublayer(
-            conv_cls_name,
-            nn.Conv2D(
-                in_channels=256,
-                out_channels=self.num_classes,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                weight_attr=ParamAttr(
-                    name=conv_cls_name + "_weights",
-                    initializer=Normal(
-                        mean=0., std=0.01)),
-                bias_attr=ParamAttr(
-                    name=conv_cls_name + "_bias",
-                    initializer=Constant(value=bias_init_value))))
-
-        conv_reg_name = "fcos_head_reg"
-        self.fcos_head_reg = self.add_sublayer(
-            conv_reg_name,
-            nn.Conv2D(
-                in_channels=256,
-                out_channels=4,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                weight_attr=ParamAttr(
-                    name=conv_reg_name + "_weights",
-                    initializer=Normal(
-                        mean=0., std=0.01)),
-                bias_attr=ParamAttr(
-                    name=conv_reg_name + "_bias",
-                    initializer=Constant(value=0))))
-
-        conv_centerness_name = "fcos_head_centerness"
-        self.fcos_head_centerness = self.add_sublayer(
-            conv_centerness_name,
-            nn.Conv2D(
-                in_channels=256,
-                out_channels=1,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                weight_attr=ParamAttr(
-                    name=conv_centerness_name + "_weights",
-                    initializer=Normal(
-                        mean=0., std=0.01)),
-                bias_attr=ParamAttr(
-                    name=conv_centerness_name + "_bias",
-                    initializer=Constant(value=0))))
-
-        self.scales_regs = []
-        for i in range(len(self.fpn_stride)):
-            lvl = int(math.log(int(self.fpn_stride[i]), 2))
-            feat_name = 'p{}_feat'.format(lvl)
-            scale_reg = self.add_sublayer(feat_name, ScaleReg())
-            self.scales_regs.append(scale_reg)
-
-    def _compute_locations_by_level(self, fpn_stride, feature):
-        """
-        Compute locations of anchor points of each FPN layer
-        Args:
-            fpn_stride (int): The stride of current FPN feature map
-            feature (Tensor): Tensor of current FPN feature map
-        Return:
-            Anchor points locations of current FPN feature map
-        """
-        shape_fm = paddle.shape(feature)
-        shape_fm.stop_gradient = True
-        h, w = shape_fm[2], shape_fm[3]
-        shift_x = paddle.arange(0, w * fpn_stride, fpn_stride)
-        shift_y = paddle.arange(0, h * fpn_stride, fpn_stride)
-        shift_x = paddle.unsqueeze(shift_x, axis=0)
-        shift_y = paddle.unsqueeze(shift_y, axis=1)
-        shift_x = paddle.expand(shift_x, shape=[h, w])
-        shift_y = paddle.expand(shift_y, shape=[h, w])
-        shift_x.stop_gradient = True
-        shift_y.stop_gradient = True
-        shift_x = paddle.reshape(shift_x, shape=[-1])
-        shift_y = paddle.reshape(shift_y, shape=[-1])
-        location = paddle.stack(
-            [shift_x, shift_y], axis=-1) + float(fpn_stride) / 2
-        location.stop_gradient = True
-        return location
-
-    def forward(self, fpn_feats, is_training):
-        assert len(fpn_feats) == len(
-            self.fpn_stride
-        ), "The size of fpn_feats is not equal to size of fpn_stride"
-        cls_logits_list = []
-        bboxes_reg_list = []
-        centerness_list = []
-        for scale_reg, fpn_stride, fpn_feat in zip(self.scales_regs,
-                                                   self.fpn_stride, fpn_feats):
-            fcos_cls_feat, fcos_reg_feat = self.fcos_feat(fpn_feat)
-            cls_logits = self.fcos_head_cls(fcos_cls_feat)
-            bbox_reg = scale_reg(self.fcos_head_reg(fcos_reg_feat))
-            if self.centerness_on_reg:
-                centerness = self.fcos_head_centerness(fcos_reg_feat)
-            else:
-                centerness = self.fcos_head_centerness(fcos_cls_feat)
-            if self.norm_reg_targets:
-                bbox_reg = F.relu(bbox_reg)
-                if not is_training:
-                    bbox_reg = bbox_reg * fpn_stride
-            else:
-                bbox_reg = paddle.exp(bbox_reg)
-            cls_logits_list.append(cls_logits)
-            bboxes_reg_list.append(bbox_reg)
-            centerness_list.append(centerness)
-
-        if not is_training:
-            locations_list = []
-            for fpn_stride, feature in zip(self.fpn_stride, fpn_feats):
-                location = self._compute_locations_by_level(fpn_stride,
-                                                            feature)
-                locations_list.append(location)
-
-            return locations_list, cls_logits_list, bboxes_reg_list, centerness_list
-        else:
-            return cls_logits_list, bboxes_reg_list, centerness_list
-
-    def get_loss(self, fcos_head_outs, tag_labels, tag_bboxes, tag_centerness):
-        cls_logits, bboxes_reg, centerness = fcos_head_outs
-        return self.fcos_loss(cls_logits, bboxes_reg, centerness, tag_labels,
-                              tag_bboxes, tag_centerness)

paddlex/ppdet/modeling/heads/keypoint_hrhrnet_head.py

@@ -1,108 +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.ppdet.core.workspace import register
-from .. import layers as L
-from ..backbones.hrnet import BasicBlock
-
-
-@register
-class HrHRNetHead(nn.Layer):
-    __inject__ = ['loss']
-
-    def __init__(self, num_joints, loss='HrHRNetLoss', swahr=False, width=32):
-        """
-        Head for HigherHRNet network
-
-        Args:
-            num_joints (int): number of keypoints
-            hrloss (object): HrHRNetLoss instance
-            swahr (bool): whether to use swahr
-            width (int): hrnet channel width
-        """
-        super(HrHRNetHead, self).__init__()
-        self.loss = loss
-
-        self.num_joints = num_joints
-        num_featout1 = num_joints * 2
-        num_featout2 = num_joints
-        self.swahr = swahr
-        self.conv1 = L.Conv2d(width, num_featout1, 1, 1, 0, bias=True)
-        self.conv2 = L.Conv2d(width, num_featout2, 1, 1, 0, bias=True)
-        self.deconv = nn.Sequential(
-            L.ConvTranspose2d(
-                num_featout1 + width, width, 4, 2, 1, 0, bias=False),
-            L.BatchNorm2d(width),
-            L.ReLU())
-        self.blocks = nn.Sequential(*(BasicBlock(
-            num_channels=width,
-            num_filters=width,
-            has_se=False,
-            freeze_norm=False,
-            name='HrHRNetHead_{}'.format(i)) for i in range(4)))
-
-        self.interpolate = L.Upsample(2, mode='bilinear')
-        self.concat = L.Concat(dim=1)
-        if swahr:
-            self.scalelayer0 = nn.Sequential(
-                L.Conv2d(
-                    width, num_joints, 1, 1, 0, bias=True),
-                L.BatchNorm2d(num_joints),
-                L.ReLU(),
-                L.Conv2d(
-                    num_joints,
-                    num_joints,
-                    9,
-                    1,
-                    4,
-                    groups=num_joints,
-                    bias=True))
-            self.scalelayer1 = nn.Sequential(
-                L.Conv2d(
-                    width, num_joints, 1, 1, 0, bias=True),
-                L.BatchNorm2d(num_joints),
-                L.ReLU(),
-                L.Conv2d(
-                    num_joints,
-                    num_joints,
-                    9,
-                    1,
-                    4,
-                    groups=num_joints,
-                    bias=True))
-
-    def forward(self, feats, targets=None):
-        x1 = feats[0]
-        xo1 = self.conv1(x1)
-        x2 = self.blocks(self.deconv(self.concat((x1, xo1))))
-        xo2 = self.conv2(x2)
-        num_joints = self.num_joints
-        if self.training:
-            heatmap1, tagmap = paddle.split(xo1, 2, axis=1)
-            if self.swahr:
-                so1 = self.scalelayer0(x1)
-                so2 = self.scalelayer1(x2)
-                hrhrnet_outputs = ([heatmap1, so1], [xo2, so2], tagmap)
-                return self.loss(hrhrnet_outputs, targets)
-            else:
-                hrhrnet_outputs = (heatmap1, xo2, tagmap)
-                return self.loss(hrhrnet_outputs, targets)
-
-        # averaged heatmap, upsampled tagmap
-        upsampled = self.interpolate(xo1)
-        avg = (upsampled[:, :num_joints] + xo2[:, :num_joints]) / 2
-        return avg, upsampled[:, num_joints:]