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

paddlex/ppdet/modeling/architectures/keypoint_hrnet.py

@@ -1,203 +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 numpy as np
-import math
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-from ..keypoint_utils import transform_preds
-from .. import layers as L
-
-__all__ = ['TopDownHRNet']
-
-
-@register
-class TopDownHRNet(BaseArch):
-    __category__ = 'architecture'
-    __inject__ = ['loss']
-
-    def __init__(self,
-                 width,
-                 num_joints,
-                 backbone='HRNet',
-                 loss='KeyPointMSELoss',
-                 post_process='HRNetPostProcess',
-                 flip_perm=None,
-                 flip=True,
-                 shift_heatmap=True):
-        """
-        HRNnet network, see https://arxiv.org/abs/1902.09212
-
-        Args:
-            backbone (nn.Layer): backbone instance
-            post_process (object): `HRNetPostProcess` instance
-            flip_perm (list): The left-right joints exchange order list
-        """
-        super(TopDownHRNet, self).__init__()
-        self.backbone = backbone
-        self.post_process = HRNetPostProcess()
-        self.loss = loss
-        self.flip_perm = flip_perm
-        self.flip = flip
-        self.final_conv = L.Conv2d(width, num_joints, 1, 1, 0, bias=True)
-        self.shift_heatmap = shift_heatmap
-        self.deploy = False
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        # backbone
-        backbone = create(cfg['backbone'])
-
-        return {'backbone': backbone, }
-
-    def _forward(self):
-        feats = self.backbone(self.inputs)
-        hrnet_outputs = self.final_conv(feats[0])
-
-        if self.training:
-            return self.loss(hrnet_outputs, self.inputs)
-        elif self.deploy:
-            return hrnet_outputs
-        else:
-            if self.flip:
-                self.inputs['image'] = self.inputs['image'].flip([3])
-                feats = self.backbone(self.inputs)
-                output_flipped = self.final_conv(feats[0])
-                output_flipped = self.flip_back(output_flipped.numpy(),
-                                                self.flip_perm)
-                output_flipped = paddle.to_tensor(output_flipped.copy())
-                if self.shift_heatmap:
-                    output_flipped[:, :, :, 1:] = output_flipped.clone(
-                    )[:, :, :, 0:-1]
-                hrnet_outputs = (hrnet_outputs + output_flipped) * 0.5
-            imshape = (self.inputs['im_shape'].numpy()
-                       )[:, ::-1] if 'im_shape' in self.inputs else None
-            center = self.inputs['center'].numpy(
-            ) if 'center' in self.inputs else np.round(imshape / 2.)
-            scale = self.inputs['scale'].numpy(
-            ) if 'scale' in self.inputs else imshape / 200.
-            outputs = self.post_process(hrnet_outputs, center, scale)
-            return outputs
-
-    def get_loss(self):
-        return self._forward()
-
-    def get_pred(self):
-        res_lst = self._forward()
-        outputs = {'keypoint': res_lst}
-        return outputs
-
-    def flip_back(self, output_flipped, matched_parts):
-        assert output_flipped.ndim == 4,\
-                'output_flipped should be [batch_size, num_joints, height, width]'
-
-        output_flipped = output_flipped[:, :, :, ::-1]
-
-        for pair in matched_parts:
-            tmp = output_flipped[:, pair[0], :, :].copy()
-            output_flipped[:, pair[0], :, :] = output_flipped[:, pair[1], :, :]
-            output_flipped[:, pair[1], :, :] = tmp
-
-        return output_flipped
-
-
-class HRNetPostProcess(object):
-    def get_max_preds(self, heatmaps):
-        '''get predictions from score maps
-
-        Args:
-            heatmaps: numpy.ndarray([batch_size, num_joints, height, width])
-
-        Returns:
-            preds: numpy.ndarray([batch_size, num_joints, 2]), keypoints coords
-            maxvals: numpy.ndarray([batch_size, num_joints, 2]), the maximum confidence of the keypoints
-        '''
-        assert isinstance(heatmaps,
-                          np.ndarray), 'heatmaps should be numpy.ndarray'
-        assert heatmaps.ndim == 4, 'batch_images should be 4-ndim'
-
-        batch_size = heatmaps.shape[0]
-        num_joints = heatmaps.shape[1]
-        width = heatmaps.shape[3]
-        heatmaps_reshaped = heatmaps.reshape((batch_size, num_joints, -1))
-        idx = np.argmax(heatmaps_reshaped, 2)
-        maxvals = np.amax(heatmaps_reshaped, 2)
-
-        maxvals = maxvals.reshape((batch_size, num_joints, 1))
-        idx = idx.reshape((batch_size, num_joints, 1))
-
-        preds = np.tile(idx, (1, 1, 2)).astype(np.float32)
-
-        preds[:, :, 0] = (preds[:, :, 0]) % width
-        preds[:, :, 1] = np.floor((preds[:, :, 1]) / width)
-
-        pred_mask = np.tile(np.greater(maxvals, 0.0), (1, 1, 2))
-        pred_mask = pred_mask.astype(np.float32)
-
-        preds *= pred_mask
-
-        return preds, maxvals
-
-    def get_final_preds(self, heatmaps, center, scale):
-        """the highest heatvalue location with a quarter offset in the
-        direction from the highest response to the second highest response.
-
-        Args:
-            heatmaps (numpy.ndarray): The predicted heatmaps
-            center (numpy.ndarray): The boxes center
-            scale (numpy.ndarray): The scale factor
-
-        Returns:
-            preds: numpy.ndarray([batch_size, num_joints, 2]), keypoints coords
-            maxvals: numpy.ndarray([batch_size, num_joints, 1]), the maximum confidence of the keypoints
-        """
-
-        coords, maxvals = self.get_max_preds(heatmaps)
-
-        heatmap_height = heatmaps.shape[2]
-        heatmap_width = heatmaps.shape[3]
-
-        for n in range(coords.shape[0]):
-            for p in range(coords.shape[1]):
-                hm = heatmaps[n][p]
-                px = int(math.floor(coords[n][p][0] + 0.5))
-                py = int(math.floor(coords[n][p][1] + 0.5))
-                if 1 < px < heatmap_width - 1 and 1 < py < heatmap_height - 1:
-                    diff = np.array([
-                        hm[py][px + 1] - hm[py][px - 1],
-                        hm[py + 1][px] - hm[py - 1][px]
-                    ])
-                    coords[n][p] += np.sign(diff) * .25
-        preds = coords.copy()
-
-        # Transform back
-        for i in range(coords.shape[0]):
-            preds[i] = transform_preds(coords[i], center[i], scale[i],
-                                       [heatmap_width, heatmap_height])
-
-        return preds, maxvals
-
-    def __call__(self, output, center, scale):
-        preds, maxvals = self.get_final_preds(output.numpy(), center, scale)
-        outputs = [[
-            np.concatenate(
-                (preds, maxvals), axis=-1), np.mean(
-                    maxvals, axis=1)
-        ]]
-        return outputs

paddlex/ppdet/modeling/architectures/mask_rcnn.py

@@ -1,135 +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 paddle
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-
-__all__ = ['MaskRCNN']
-
-
-@register
-class MaskRCNN(BaseArch):
-    """
-    Mask R-CNN network, see https://arxiv.org/abs/1703.06870
-
-    Args:
-        backbone (object): backbone instance
-        rpn_head (object): `RPNHead` instance
-        bbox_head (object): `BBoxHead` instance
-        mask_head (object): `MaskHead` instance
-        bbox_post_process (object): `BBoxPostProcess` instance
-        mask_post_process (object): `MaskPostProcess` instance
-        neck (object): 'FPN' instance
-    """
-
-    __category__ = 'architecture'
-    __inject__ = [
-        'bbox_post_process',
-        'mask_post_process',
-    ]
-
-    def __init__(self,
-                 backbone,
-                 rpn_head,
-                 bbox_head,
-                 mask_head,
-                 bbox_post_process,
-                 mask_post_process,
-                 neck=None):
-        super(MaskRCNN, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.rpn_head = rpn_head
-        self.bbox_head = bbox_head
-        self.mask_head = mask_head
-
-        self.bbox_post_process = bbox_post_process
-        self.mask_post_process = mask_post_process
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        backbone = create(cfg['backbone'])
-        kwargs = {'input_shape': backbone.out_shape}
-        neck = cfg['neck'] and create(cfg['neck'], **kwargs)
-
-        out_shape = neck and neck.out_shape or backbone.out_shape
-        kwargs = {'input_shape': out_shape}
-        rpn_head = create(cfg['rpn_head'], **kwargs)
-        bbox_head = create(cfg['bbox_head'], **kwargs)
-
-        out_shape = neck and out_shape or bbox_head.get_head().out_shape
-        kwargs = {'input_shape': out_shape}
-        mask_head = create(cfg['mask_head'], **kwargs)
-        return {
-            'backbone': backbone,
-            'neck': neck,
-            "rpn_head": rpn_head,
-            "bbox_head": bbox_head,
-            "mask_head": mask_head,
-        }
-
-    def _forward(self):
-        body_feats = self.backbone(self.inputs)
-        if self.neck is not None:
-            body_feats = self.neck(body_feats)
-
-        if self.training:
-            rois, rois_num, rpn_loss = self.rpn_head(body_feats, self.inputs)
-            bbox_loss, bbox_feat = self.bbox_head(body_feats, rois, rois_num,
-                                                  self.inputs)
-            rois, rois_num = self.bbox_head.get_assigned_rois()
-            bbox_targets = self.bbox_head.get_assigned_targets()
-            # Mask Head needs bbox_feat in Mask RCNN
-            mask_loss = self.mask_head(body_feats, rois, rois_num, self.inputs,
-                                       bbox_targets, bbox_feat)
-            return rpn_loss, bbox_loss, mask_loss
-        else:
-            rois, rois_num, _ = self.rpn_head(body_feats, self.inputs)
-            preds, feat_func = self.bbox_head(body_feats, rois, rois_num, None)
-
-            im_shape = self.inputs['im_shape']
-            scale_factor = self.inputs['scale_factor']
-
-            bbox, bbox_num = self.bbox_post_process(preds, (rois, rois_num),
-                                                    im_shape, scale_factor)
-            mask_out = self.mask_head(
-                body_feats, bbox, bbox_num, self.inputs, feat_func=feat_func)
-
-            # rescale the prediction back to origin image
-            bbox_pred = self.bbox_post_process.get_pred(bbox, bbox_num,
-                                                        im_shape, scale_factor)
-            origin_shape = self.bbox_post_process.get_origin_shape()
-            mask_pred = self.mask_post_process(mask_out[:, 0, :, :], bbox_pred,
-                                               bbox_num, origin_shape)
-            return bbox_pred, bbox_num, mask_pred
-
-    def get_loss(self, ):
-        bbox_loss, mask_loss, rpn_loss = self._forward()
-        loss = {}
-        loss.update(rpn_loss)
-        loss.update(bbox_loss)
-        loss.update(mask_loss)
-        total_loss = paddle.add_n(list(loss.values()))
-        loss.update({'loss': total_loss})
-        return loss
-
-    def get_pred(self):
-        bbox_pred, bbox_num, mask_pred = self._forward()
-        output = {'bbox': bbox_pred, 'bbox_num': bbox_num, 'mask': mask_pred}
-        return output

paddlex/ppdet/modeling/architectures/meta_arch.py

@@ -1,45 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-import paddle
-import paddle.nn as nn
-from paddlex.ppdet.core.workspace import register
-
-__all__ = ['BaseArch']
-
-
-@register
-class BaseArch(nn.Layer):
-    def __init__(self, data_format='NCHW'):
-        super(BaseArch, self).__init__()
-        self.data_format = data_format
-
-    def forward(self, inputs):
-        if self.data_format == 'NHWC':
-            image = inputs['image']
-            inputs['image'] = paddle.transpose(image, [0, 2, 3, 1])
-        self.inputs = inputs
-        self.model_arch()
-
-        if self.training:
-            out = self.get_loss()
-        else:
-            out = self.get_pred()
-        return out
-
-    def build_inputs(self, data, input_def):
-        inputs = {}
-        for i, k in enumerate(input_def):
-            inputs[k] = data[i]
-        return inputs
-
-    def model_arch(self, ):
-        pass
-
-    def get_loss(self, ):
-        raise NotImplementedError("Should implement get_loss method!")
-
-    def get_pred(self, ):
-        raise NotImplementedError("Should implement get_pred method!")

paddlex/ppdet/modeling/architectures/s2anet.py

@@ -1,103 +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
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-import numpy as np
-
-__all__ = ['S2ANet']
-
-
-@register
-class S2ANet(BaseArch):
-    __category__ = 'architecture'
-    __inject__ = [
-        's2anet_head',
-        's2anet_bbox_post_process',
-    ]
-
-    def __init__(self, backbone, neck, s2anet_head, s2anet_bbox_post_process):
-        """
-        S2ANet, see https://arxiv.org/pdf/2008.09397.pdf
-
-        Args:
-            backbone (object): backbone instance
-            neck (object): `FPN` instance
-            s2anet_head (object): `S2ANetHead` instance
-            s2anet_bbox_post_process (object): `S2ANetBBoxPostProcess` instance
-        """
-        super(S2ANet, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.s2anet_head = s2anet_head
-        self.s2anet_bbox_post_process = s2anet_bbox_post_process
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        backbone = create(cfg['backbone'])
-        kwargs = {'input_shape': backbone.out_shape}
-        neck = cfg['neck'] and create(cfg['neck'], **kwargs)
-
-        out_shape = neck and neck.out_shape or backbone.out_shape
-        kwargs = {'input_shape': out_shape}
-        s2anet_head = create(cfg['s2anet_head'], **kwargs)
-        s2anet_bbox_post_process = create(cfg['s2anet_bbox_post_process'],
-                                          **kwargs)
-
-        return {
-            'backbone': backbone,
-            'neck': neck,
-            "s2anet_head": s2anet_head,
-            "s2anet_bbox_post_process": s2anet_bbox_post_process,
-        }
-
-    def _forward(self):
-        body_feats = self.backbone(self.inputs)
-        if self.neck is not None:
-            body_feats = self.neck(body_feats)
-        self.s2anet_head(body_feats)
-        if self.training:
-            loss = self.s2anet_head.get_loss(self.inputs)
-            total_loss = paddle.add_n(list(loss.values()))
-            loss.update({'loss': total_loss})
-            return loss
-        else:
-            im_shape = self.inputs['im_shape']
-            scale_factor = self.inputs['scale_factor']
-            nms_pre = self.s2anet_bbox_post_process.nms_pre
-            pred_scores, pred_bboxes = self.s2anet_head.get_prediction(nms_pre)
-
-            # post_process
-            pred_bboxes, bbox_num = self.s2anet_bbox_post_process(pred_scores,
-                                                                  pred_bboxes)
-            # rescale the prediction back to origin image
-            pred_bboxes = self.s2anet_bbox_post_process.get_pred(
-                pred_bboxes, bbox_num, im_shape, scale_factor)
-
-            # output
-            output = {'bbox': pred_bboxes, 'bbox_num': bbox_num}
-            return output
-
-    def get_loss(self, ):
-        loss = self._forward()
-        return loss
-
-    def get_pred(self):
-        output = self._forward()
-        return output

paddlex/ppdet/modeling/architectures/solov2.py

@@ -1,110 +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 paddle
-
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-
-__all__ = ['SOLOv2']
-
-
-@register
-class SOLOv2(BaseArch):
-    """
-    SOLOv2 network, see https://arxiv.org/abs/2003.10152
-
-    Args:
-        backbone (object): an backbone instance
-        solov2_head (object): an `SOLOv2Head` instance
-        mask_head (object): an `SOLOv2MaskHead` instance
-        neck (object): neck of network, such as feature pyramid network instance
-    """
-
-    __category__ = 'architecture'
-
-    def __init__(self, backbone, solov2_head, mask_head, neck=None):
-        super(SOLOv2, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.solov2_head = solov2_head
-        self.mask_head = mask_head
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        backbone = create(cfg['backbone'])
-
-        kwargs = {'input_shape': backbone.out_shape}
-        neck = create(cfg['neck'], **kwargs)
-
-        kwargs = {'input_shape': neck.out_shape}
-        solov2_head = create(cfg['solov2_head'], **kwargs)
-        mask_head = create(cfg['mask_head'], **kwargs)
-
-        return {
-            'backbone': backbone,
-            'neck': neck,
-            'solov2_head': solov2_head,
-            'mask_head': mask_head,
-        }
-
-    def model_arch(self):
-        body_feats = self.backbone(self.inputs)
-
-        body_feats = self.neck(body_feats)
-
-        self.seg_pred = self.mask_head(body_feats)
-
-        self.cate_pred_list, self.kernel_pred_list = self.solov2_head(
-            body_feats)
-
-    def get_loss(self, ):
-        loss = {}
-        # get gt_ins_labels, gt_cate_labels, etc.
-        gt_ins_labels, gt_cate_labels, gt_grid_orders = [], [], []
-        fg_num = self.inputs['fg_num']
-        for i in range(len(self.solov2_head.seg_num_grids)):
-            ins_label = 'ins_label{}'.format(i)
-            if ins_label in self.inputs:
-                gt_ins_labels.append(self.inputs[ins_label])
-            cate_label = 'cate_label{}'.format(i)
-            if cate_label in self.inputs:
-                gt_cate_labels.append(self.inputs[cate_label])
-            grid_order = 'grid_order{}'.format(i)
-            if grid_order in self.inputs:
-                gt_grid_orders.append(self.inputs[grid_order])
-
-        loss_solov2 = self.solov2_head.get_loss(
-            self.cate_pred_list, self.kernel_pred_list, self.seg_pred,
-            gt_ins_labels, gt_cate_labels, gt_grid_orders, fg_num)
-        loss.update(loss_solov2)
-        total_loss = paddle.add_n(list(loss.values()))
-        loss.update({'loss': total_loss})
-        return loss
-
-    def get_pred(self):
-        seg_masks, cate_labels, cate_scores, bbox_num = self.solov2_head.get_prediction(
-            self.cate_pred_list, self.kernel_pred_list, self.seg_pred,
-            self.inputs['im_shape'], self.inputs['scale_factor'])
-        outs = {
-            "segm": seg_masks,
-            "bbox_num": bbox_num,
-            'cate_label': cate_labels,
-            'cate_score': cate_scores
-        }
-        return outs

paddlex/ppdet/modeling/architectures/ssd.py

@@ -1,84 +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
-
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-
-__all__ = ['SSD']
-
-
-@register
-class SSD(BaseArch):
-    """
-    Single Shot MultiBox Detector, see https://arxiv.org/abs/1512.02325
-
-    Args:
-        backbone (nn.Layer): backbone instance
-        ssd_head (nn.Layer): `SSDHead` instance
-        post_process (object): `BBoxPostProcess` instance
-    """
-
-    __category__ = 'architecture'
-    __inject__ = ['post_process']
-
-    def __init__(self, backbone, ssd_head, post_process):
-        super(SSD, self).__init__()
-        self.backbone = backbone
-        self.ssd_head = ssd_head
-        self.post_process = post_process
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        # backbone
-        backbone = create(cfg['backbone'])
-
-        # head
-        kwargs = {'input_shape': backbone.out_shape}
-        ssd_head = create(cfg['ssd_head'], **kwargs)
-
-        return {
-            'backbone': backbone,
-            "ssd_head": ssd_head,
-        }
-
-    def _forward(self):
-        # Backbone
-        body_feats = self.backbone(self.inputs)
-
-        # SSD Head
-        if self.training:
-            return self.ssd_head(body_feats, self.inputs['image'],
-                                 self.inputs['gt_bbox'],
-                                 self.inputs['gt_class'])
-        else:
-            preds, anchors = self.ssd_head(body_feats, self.inputs['image'])
-            bbox, bbox_num = self.post_process(preds, anchors,
-                                               self.inputs['im_shape'],
-                                               self.inputs['scale_factor'])
-            return bbox, bbox_num
-
-    def get_loss(self, ):
-        return {"loss": self._forward()}
-
-    def get_pred(self):
-        bbox_pred, bbox_num = self._forward()
-        output = {
-            "bbox": bbox_pred,
-            "bbox_num": bbox_num,
-        }
-        return output