paddlex 2.1.0__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/ppdet/modeling/transformers/detr_transformer.py

@@ -1,353 +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.
-#
-# Modified from DETR (https://github.com/facebookresearch/detr)
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-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 paddlex.ppdet.core.workspace import register
-from ..layers import MultiHeadAttention, _convert_attention_mask
-from .position_encoding import PositionEmbedding
-from .utils import _get_clones
-from ..initializer import linear_init_, conv_init_, xavier_uniform_, normal_
-
-__all__ = ['DETRTransformer']
-
-
-class TransformerEncoderLayer(nn.Layer):
-    def __init__(self,
-                 d_model,
-                 nhead,
-                 dim_feedforward=2048,
-                 dropout=0.1,
-                 activation="relu",
-                 attn_dropout=None,
-                 act_dropout=None,
-                 normalize_before=False):
-        super(TransformerEncoderLayer, self).__init__()
-        attn_dropout = dropout if attn_dropout is None else attn_dropout
-        act_dropout = dropout if act_dropout is None else act_dropout
-        self.normalize_before = normalize_before
-
-        self.self_attn = MultiHeadAttention(d_model, nhead, attn_dropout)
-        # Implementation of Feedforward model
-        self.linear1 = nn.Linear(d_model, dim_feedforward)
-        self.dropout = nn.Dropout(act_dropout, mode="upscale_in_train")
-        self.linear2 = nn.Linear(dim_feedforward, d_model)
-
-        self.norm1 = nn.LayerNorm(d_model)
-        self.norm2 = nn.LayerNorm(d_model)
-        self.dropout1 = nn.Dropout(dropout, mode="upscale_in_train")
-        self.dropout2 = nn.Dropout(dropout, mode="upscale_in_train")
-        self.activation = getattr(F, activation)
-        self._reset_parameters()
-
-    def _reset_parameters(self):
-        linear_init_(self.linear1)
-        linear_init_(self.linear2)
-
-    @staticmethod
-    def with_pos_embed(tensor, pos_embed):
-        return tensor if pos_embed is None else tensor + pos_embed
-
-    def forward(self, src, src_mask=None, pos_embed=None):
-        src_mask = _convert_attention_mask(src_mask, src.dtype)
-
-        residual = src
-        if self.normalize_before:
-            src = self.norm1(src)
-        q = k = self.with_pos_embed(src, pos_embed)
-        src = self.self_attn(q, k, value=src, attn_mask=src_mask)
-
-        src = residual + self.dropout1(src)
-        if not self.normalize_before:
-            src = self.norm1(src)
-
-        residual = src
-        if self.normalize_before:
-            src = self.norm2(src)
-        src = self.linear2(self.dropout(self.activation(self.linear1(src))))
-        src = residual + self.dropout2(src)
-        if not self.normalize_before:
-            src = self.norm2(src)
-        return src
-
-
-class TransformerEncoder(nn.Layer):
-    def __init__(self, encoder_layer, num_layers, norm=None):
-        super(TransformerEncoder, self).__init__()
-        self.layers = _get_clones(encoder_layer, num_layers)
-        self.num_layers = num_layers
-        self.norm = norm
-
-    def forward(self, src, src_mask=None, pos_embed=None):
-        src_mask = _convert_attention_mask(src_mask, src.dtype)
-
-        output = src
-        for layer in self.layers:
-            output = layer(output, src_mask=src_mask, pos_embed=pos_embed)
-
-        if self.norm is not None:
-            output = self.norm(output)
-
-        return output
-
-
-class TransformerDecoderLayer(nn.Layer):
-    def __init__(self,
-                 d_model,
-                 nhead,
-                 dim_feedforward=2048,
-                 dropout=0.1,
-                 activation="relu",
-                 attn_dropout=None,
-                 act_dropout=None,
-                 normalize_before=False):
-        super(TransformerDecoderLayer, self).__init__()
-        attn_dropout = dropout if attn_dropout is None else attn_dropout
-        act_dropout = dropout if act_dropout is None else act_dropout
-        self.normalize_before = normalize_before
-
-        self.self_attn = MultiHeadAttention(d_model, nhead, attn_dropout)
-        self.cross_attn = MultiHeadAttention(d_model, nhead, attn_dropout)
-        # Implementation of Feedforward model
-        self.linear1 = nn.Linear(d_model, dim_feedforward)
-        self.dropout = nn.Dropout(act_dropout, mode="upscale_in_train")
-        self.linear2 = nn.Linear(dim_feedforward, d_model)
-
-        self.norm1 = nn.LayerNorm(d_model)
-        self.norm2 = nn.LayerNorm(d_model)
-        self.norm3 = nn.LayerNorm(d_model)
-        self.dropout1 = nn.Dropout(dropout, mode="upscale_in_train")
-        self.dropout2 = nn.Dropout(dropout, mode="upscale_in_train")
-        self.dropout3 = nn.Dropout(dropout, mode="upscale_in_train")
-        self.activation = getattr(F, activation)
-        self._reset_parameters()
-
-    def _reset_parameters(self):
-        linear_init_(self.linear1)
-        linear_init_(self.linear2)
-
-    @staticmethod
-    def with_pos_embed(tensor, pos_embed):
-        return tensor if pos_embed is None else tensor + pos_embed
-
-    def forward(self,
-                tgt,
-                memory,
-                tgt_mask=None,
-                memory_mask=None,
-                pos_embed=None,
-                query_pos_embed=None):
-        tgt_mask = _convert_attention_mask(tgt_mask, tgt.dtype)
-        memory_mask = _convert_attention_mask(memory_mask, memory.dtype)
-
-        residual = tgt
-        if self.normalize_before:
-            tgt = self.norm1(tgt)
-        q = k = self.with_pos_embed(tgt, query_pos_embed)
-        tgt = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask)
-        tgt = residual + self.dropout1(tgt)
-        if not self.normalize_before:
-            tgt = self.norm1(tgt)
-
-        residual = tgt
-        if self.normalize_before:
-            tgt = self.norm2(tgt)
-        q = self.with_pos_embed(tgt, query_pos_embed)
-        k = self.with_pos_embed(memory, pos_embed)
-        tgt = self.cross_attn(q, k, value=memory, attn_mask=memory_mask)
-        tgt = residual + self.dropout2(tgt)
-        if not self.normalize_before:
-            tgt = self.norm2(tgt)
-
-        residual = tgt
-        if self.normalize_before:
-            tgt = self.norm3(tgt)
-        tgt = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
-        tgt = residual + self.dropout3(tgt)
-        if not self.normalize_before:
-            tgt = self.norm3(tgt)
-        return tgt
-
-
-class TransformerDecoder(nn.Layer):
-    def __init__(self,
-                 decoder_layer,
-                 num_layers,
-                 norm=None,
-                 return_intermediate=False):
-        super(TransformerDecoder, self).__init__()
-        self.layers = _get_clones(decoder_layer, num_layers)
-        self.num_layers = num_layers
-        self.norm = norm
-        self.return_intermediate = return_intermediate
-
-    def forward(self,
-                tgt,
-                memory,
-                tgt_mask=None,
-                memory_mask=None,
-                pos_embed=None,
-                query_pos_embed=None):
-        tgt_mask = _convert_attention_mask(tgt_mask, tgt.dtype)
-        memory_mask = _convert_attention_mask(memory_mask, memory.dtype)
-
-        output = tgt
-        intermediate = []
-        for layer in self.layers:
-            output = layer(
-                output,
-                memory,
-                tgt_mask=tgt_mask,
-                memory_mask=memory_mask,
-                pos_embed=pos_embed,
-                query_pos_embed=query_pos_embed)
-            if self.return_intermediate:
-                intermediate.append(self.norm(output))
-
-        if self.norm is not None:
-            output = self.norm(output)
-
-        if self.return_intermediate:
-            return paddle.stack(intermediate)
-
-        return output.unsqueeze(0)
-
-
-@register
-class DETRTransformer(nn.Layer):
-    __shared__ = ['hidden_dim']
-
-    def __init__(self,
-                 num_queries=100,
-                 position_embed_type='sine',
-                 return_intermediate_dec=True,
-                 backbone_num_channels=2048,
-                 hidden_dim=256,
-                 nhead=8,
-                 num_encoder_layers=6,
-                 num_decoder_layers=6,
-                 dim_feedforward=2048,
-                 dropout=0.1,
-                 activation="relu",
-                 attn_dropout=None,
-                 act_dropout=None,
-                 normalize_before=False):
-        super(DETRTransformer, self).__init__()
-        assert position_embed_type in ['sine', 'learned'],\
-            f'ValueError: position_embed_type not supported {position_embed_type}!'
-        self.hidden_dim = hidden_dim
-        self.nhead = nhead
-
-        encoder_layer = TransformerEncoderLayer(
-            hidden_dim, nhead, dim_feedforward, dropout, activation,
-            attn_dropout, act_dropout, normalize_before)
-        encoder_norm = nn.LayerNorm(hidden_dim) if normalize_before else None
-        self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers,
-                                          encoder_norm)
-
-        decoder_layer = TransformerDecoderLayer(
-            hidden_dim, nhead, dim_feedforward, dropout, activation,
-            attn_dropout, act_dropout, normalize_before)
-        decoder_norm = nn.LayerNorm(hidden_dim)
-        self.decoder = TransformerDecoder(
-            decoder_layer,
-            num_decoder_layers,
-            decoder_norm,
-            return_intermediate=return_intermediate_dec)
-
-        self.input_proj = nn.Conv2D(
-            backbone_num_channels, hidden_dim, kernel_size=1)
-        self.query_pos_embed = nn.Embedding(num_queries, hidden_dim)
-        self.position_embedding = PositionEmbedding(
-            hidden_dim // 2,
-            normalize=True if position_embed_type == 'sine' else False,
-            embed_type=position_embed_type)
-
-        self._reset_parameters()
-
-    def _reset_parameters(self):
-        for p in self.parameters():
-            if p.dim() > 1:
-                xavier_uniform_(p)
-        conv_init_(self.input_proj)
-        normal_(self.query_pos_embed.weight)
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        return {
-            'backbone_num_channels': [i.channels for i in input_shape][-1],
-        }
-
-    def forward(self, src, src_mask=None):
-        r"""
-        Applies a Transformer model on the inputs.
-
-        Parameters:
-            src (List(Tensor)): Backbone feature maps with shape [[bs, c, h, w]].
-            src_mask (Tensor, optional): A tensor used in multi-head attention
-                to prevents attention to some unwanted positions, usually the
-                paddings or the subsequent positions. It is a tensor with shape
-                [bs, H, W]`. When the data type is bool, the unwanted positions
-                have `False` values and the others have `True` values. When the
-                data type is int, the unwanted positions have 0 values and the
-                others have 1 values. When the data type is float, the unwanted
-                positions have `-INF` values and the others have 0 values. It
-                can be None when nothing wanted or needed to be prevented
-                attention to. Default None.
-
-        Returns:
-            output (Tensor): [num_levels, batch_size, num_queries, hidden_dim]
-            memory (Tensor): [batch_size, hidden_dim, h, w]
-        """
-        # use last level feature map
-        src_proj = self.input_proj(src[-1])
-        bs, c, h, w = src_proj.shape
-        # flatten [B, C, H, W] to [B, HxW, C]
-        src_flatten = src_proj.flatten(2).transpose([0, 2, 1])
-        if src_mask is not None:
-            src_mask = F.interpolate(
-                src_mask.unsqueeze(0).astype(src_flatten.dtype),
-                size=(h, w))[0].astype('bool')
-        else:
-            src_mask = paddle.ones([bs, h, w], dtype='bool')
-        pos_embed = self.position_embedding(src_mask).flatten(2).transpose(
-            [0, 2, 1])
-
-        src_mask = _convert_attention_mask(src_mask, src_flatten.dtype)
-        src_mask = src_mask.reshape([bs, 1, 1, -1])
-
-        memory = self.encoder(
-            src_flatten, src_mask=src_mask, pos_embed=pos_embed)
-
-        query_pos_embed = self.query_pos_embed.weight.unsqueeze(0).tile(
-            [bs, 1, 1])
-        tgt = paddle.zeros_like(query_pos_embed)
-        output = self.decoder(
-            tgt,
-            memory,
-            memory_mask=src_mask,
-            pos_embed=pos_embed,
-            query_pos_embed=query_pos_embed)
-
-        return (output, memory.transpose([0, 2, 1]).reshape([bs, c, h, w]),
-                src_proj, src_mask.reshape([bs, 1, 1, h, w]))

paddlex/ppdet/modeling/transformers/matchers.py

@@ -1,127 +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.
-#
-# Modified from DETR (https://github.com/facebookresearch/detr)
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-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 scipy.optimize import linear_sum_assignment
-
-from paddlex.ppdet.core.workspace import register, serializable
-from ..losses.iou_loss import GIoULoss
-from .utils import bbox_cxcywh_to_xyxy
-
-__all__ = ['HungarianMatcher']
-
-
-@register
-@serializable
-class HungarianMatcher(nn.Layer):
-    __shared__ = ['use_focal_loss']
-
-    def __init__(self,
-                 matcher_coeff={'class': 1,
-                                'bbox': 5,
-                                'giou': 2},
-                 use_focal_loss=False,
-                 alpha=0.25,
-                 gamma=2.0):
-        r"""
-        Args:
-            matcher_coeff (dict): The coefficient of hungarian matcher cost.
-        """
-        super(HungarianMatcher, self).__init__()
-        self.matcher_coeff = matcher_coeff
-        self.use_focal_loss = use_focal_loss
-        self.alpha = alpha
-        self.gamma = gamma
-
-        self.giou_loss = GIoULoss()
-
-    def forward(self, boxes, logits, gt_bbox, gt_class):
-        r"""
-        Args:
-            boxes (Tensor): [b, query, 4]
-            logits (Tensor): [b, query, num_classes]
-            gt_bbox (List(Tensor)): list[[n, 4]]
-            gt_class (List(Tensor)): list[[n, 1]]
-
-        Returns:
-            A list of size batch_size, containing tuples of (index_i, index_j) where:
-                - index_i is the indices of the selected predictions (in order)
-                - index_j is the indices of the corresponding selected targets (in order)
-            For each batch element, it holds:
-                len(index_i) = len(index_j) = min(num_queries, num_target_boxes)
-        """
-        bs, num_queries = boxes.shape[:2]
-
-        num_gts = sum(len(a) for a in gt_class)
-        if num_gts == 0:
-            return [(paddle.to_tensor(
-                [], dtype=paddle.int64), paddle.to_tensor(
-                    [], dtype=paddle.int64)) for _ in range(bs)]
-
-        # We flatten to compute the cost matrices in a batch
-        # [batch_size * num_queries, num_classes]
-        out_prob = F.sigmoid(logits.flatten(
-            0, 1)) if self.use_focal_loss else F.softmax(
-                logits.flatten(0, 1))
-        # [batch_size * num_queries, 4]
-        out_bbox = boxes.flatten(0, 1)
-
-        # Also concat the target labels and boxes
-        tgt_ids = paddle.concat(gt_class).flatten()
-        tgt_bbox = paddle.concat(gt_bbox)
-
-        # Compute the classification cost
-        if self.use_focal_loss:
-            neg_cost_class = (1 - self.alpha) * (out_prob**self.gamma) * (-(
-                1 - out_prob + 1e-8).log())
-            pos_cost_class = self.alpha * (
-                (1 - out_prob)**self.gamma) * (-(out_prob + 1e-8).log())
-            cost_class = paddle.gather(
-                pos_cost_class, tgt_ids, axis=1) - paddle.gather(
-                    neg_cost_class, tgt_ids, axis=1)
-        else:
-            cost_class = -paddle.gather(out_prob, tgt_ids, axis=1)
-
-        # Compute the L1 cost between boxes
-        cost_bbox = (
-            out_bbox.unsqueeze(1) - tgt_bbox.unsqueeze(0)).abs().sum(-1)
-
-        # Compute the giou cost betwen boxes
-        cost_giou = self.giou_loss(
-            bbox_cxcywh_to_xyxy(out_bbox.unsqueeze(1)),
-            bbox_cxcywh_to_xyxy(tgt_bbox.unsqueeze(0))).squeeze(-1)
-
-        # Final cost matrix
-        C = self.matcher_coeff['class'] * cost_class + self.matcher_coeff['bbox'] * cost_bbox + \
-            self.matcher_coeff['giou'] * cost_giou
-        C = C.reshape([bs, num_queries, -1])
-        C = [a.squeeze(0) for a in C.chunk(bs)]
-
-        sizes = [a.shape[0] for a in gt_bbox]
-        indices = [
-            linear_sum_assignment(c.split(sizes, -1)[i].numpy())
-            for i, c in enumerate(C)
-        ]
-        return [(paddle.to_tensor(
-            i, dtype=paddle.int64), paddle.to_tensor(
-                j, dtype=paddle.int64)) for i, j in indices]

paddlex/ppdet/modeling/transformers/position_encoding.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.
-#
-# Modified from DETR (https://github.com/facebookresearch/detr)
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import math
-import paddle
-import paddle.nn as nn
-
-from paddlex.ppdet.core.workspace import register, serializable
-
-
-@register
-@serializable
-class PositionEmbedding(nn.Layer):
-    def __init__(self,
-                 num_pos_feats=128,
-                 temperature=10000,
-                 normalize=True,
-                 scale=None,
-                 embed_type='sine',
-                 num_embeddings=50,
-                 offset=0.):
-        super(PositionEmbedding, self).__init__()
-        assert embed_type in ['sine', 'learned']
-
-        self.embed_type = embed_type
-        self.offset = offset
-        self.eps = 1e-6
-        if self.embed_type == 'sine':
-            self.num_pos_feats = num_pos_feats
-            self.temperature = temperature
-            self.normalize = normalize
-            if scale is not None and normalize is False:
-                raise ValueError("normalize should be True if scale is passed")
-            if scale is None:
-                scale = 2 * math.pi
-            self.scale = scale
-        elif self.embed_type == 'learned':
-            self.row_embed = nn.Embedding(num_embeddings, num_pos_feats)
-            self.col_embed = nn.Embedding(num_embeddings, num_pos_feats)
-        else:
-            raise ValueError(f"not supported {self.embed_type}")
-
-    def forward(self, mask):
-        """
-        Args:
-            mask (Tensor): [B, H, W]
-        Returns:
-            pos (Tensor): [B, C, H, W]
-        """
-        assert mask.dtype == paddle.bool
-        if self.embed_type == 'sine':
-            mask = mask.astype('float32')
-            y_embed = mask.cumsum(1, dtype='float32')
-            x_embed = mask.cumsum(2, dtype='float32')
-            if self.normalize:
-                y_embed = (y_embed + self.offset) / (
-                    y_embed[:, -1:, :] + self.eps) * self.scale
-                x_embed = (x_embed + self.offset) / (
-                    x_embed[:, :, -1:] + self.eps) * self.scale
-
-            dim_t = 2 * (paddle.arange(self.num_pos_feats) //
-                         2).astype('float32')
-            dim_t = self.temperature**(dim_t / self.num_pos_feats)
-
-            pos_x = x_embed.unsqueeze(-1) / dim_t
-            pos_y = y_embed.unsqueeze(-1) / dim_t
-            pos_x = paddle.stack(
-                (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()),
-                axis=4).flatten(3)
-            pos_y = paddle.stack(
-                (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()),
-                axis=4).flatten(3)
-            pos = paddle.concat((pos_y, pos_x), axis=3).transpose([0, 3, 1, 2])
-            return pos
-        elif self.embed_type == 'learned':
-            h, w = mask.shape[-2:]
-            i = paddle.arange(w)
-            j = paddle.arange(h)
-            x_emb = self.col_embed(i)
-            y_emb = self.row_embed(j)
-            pos = paddle.concat(
-                [
-                    x_emb.unsqueeze(0).repeat(h, 1, 1),
-                    y_emb.unsqueeze(1).repeat(1, w, 1),
-                ],
-                axis=-1).transpose([2, 0, 1]).unsqueeze(0).tile(mask.shape[0],
-                                                                1, 1, 1)
-            return pos
-        else:
-            raise ValueError(f"not supported {self.embed_type}")

paddlex/ppdet/modeling/transformers/utils.py

@@ -1,110 +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.
-#
-# Modified from DETR (https://github.com/facebookresearch/detr)
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import copy
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-from ..bbox_utils import bbox_overlaps
-
-__all__ = [
-    '_get_clones', 'bbox_overlaps', 'bbox_cxcywh_to_xyxy',
-    'bbox_xyxy_to_cxcywh', 'sigmoid_focal_loss', 'inverse_sigmoid',
-    'deformable_attention_core_func'
-]
-
-
-def _get_clones(module, N):
-    return nn.LayerList([copy.deepcopy(module) for _ in range(N)])
-
-
-def bbox_cxcywh_to_xyxy(x):
-    x_c, y_c, w, h = x.unbind(-1)
-    b = [(x_c - 0.5 * w), (y_c - 0.5 * h), (x_c + 0.5 * w), (y_c + 0.5 * h)]
-    return paddle.stack(b, axis=-1)
-
-
-def bbox_xyxy_to_cxcywh(x):
-    x0, y0, x1, y1 = x.unbind(-1)
-    b = [(x0 + x1) / 2, (y0 + y1) / 2, (x1 - x0), (y1 - y0)]
-    return paddle.stack(b, axis=-1)
-
-
-def sigmoid_focal_loss(logit, label, normalizer=1.0, alpha=0.25, gamma=2.0):
-    prob = F.sigmoid(logit)
-    ce_loss = F.binary_cross_entropy_with_logits(
-        logit, label, reduction="none")
-    p_t = prob * label + (1 - prob) * (1 - label)
-    loss = ce_loss * ((1 - p_t)**gamma)
-
-    if alpha >= 0:
-        alpha_t = alpha * label + (1 - alpha) * (1 - label)
-        loss = alpha_t * loss
-    return loss.mean(1).sum() / normalizer
-
-
-def inverse_sigmoid(x, eps=1e-6):
-    x = x.clip(min=0., max=1.)
-    return paddle.log(x / (1 - x + eps) + eps)
-
-
-def deformable_attention_core_func(value, value_spatial_shapes,
-                                   sampling_locations, attention_weights):
-    """
-    Args:
-        value (Tensor): [bs, value_length, n_head, c]
-        value_spatial_shapes (Tensor): [n_levels, 2]
-        sampling_locations (Tensor): [bs, query_length, n_head, n_levels, n_points, 2]
-        attention_weights (Tensor): [bs, query_length, n_head, n_levels, n_points]
-
-    Returns:
-        output (Tensor): [bs, Length_{query}, C]
-    """
-    bs, Len_v, n_head, c = value.shape
-    _, Len_q, n_head, n_levels, n_points, _ = sampling_locations.shape
-
-    value_list = value.split(value_spatial_shapes.prod(1).tolist(), axis=1)
-    sampling_grids = 2 * sampling_locations - 1
-    sampling_value_list = []
-    for level, (h, w) in enumerate(value_spatial_shapes.tolist()):
-        # N_, H_*W_, M_, D_ -> N_, H_*W_, M_*D_ -> N_, M_*D_, H_*W_ -> N_*M_, D_, H_, W_
-        value_l_ = value_list[level].flatten(2).transpose(
-            [0, 2, 1]).reshape([bs * n_head, c, h, w])
-        # N_, Lq_, M_, P_, 2 -> N_, M_, Lq_, P_, 2 -> N_*M_, Lq_, P_, 2
-        sampling_grid_l_ = sampling_grids[:, :, :, level].transpose(
-            [0, 2, 1, 3, 4]).flatten(0, 1)
-        # N_*M_, D_, Lq_, P_
-        sampling_value_l_ = F.grid_sample(
-            value_l_,
-            sampling_grid_l_,
-            mode='bilinear',
-            padding_mode='zeros',
-            align_corners=False)
-        sampling_value_list.append(sampling_value_l_)
-    # (N_, Lq_, M_, L_, P_) -> (N_, M_, Lq_, L_, P_) -> (N_*M_, 1, Lq_, L_*P_)
-    attention_weights = attention_weights.transpose([0, 2, 1, 3, 4]).reshape(
-        [bs * n_head, 1, Len_q, n_levels * n_points])
-    output = (paddle.stack(
-        sampling_value_list, axis=-2).flatten(-2) *
-              attention_weights).sum(-1).reshape([bs, n_head * c, Len_q])
-
-    return output.transpose([0, 2, 1])