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

paddlex/ppcls/data/reader.py

@@ -1,318 +0,0 @@
-# copyright (c) 2020 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.
-
-import numpy as np
-import random
-import imghdr
-import os
-import signal
-
-from paddle.io import Dataset, DataLoader, DistributedBatchSampler
-
-from . import imaug
-from .imaug import transform
-from paddlex.ppcls.utils import logger
-
-trainers_num = int(os.environ.get('PADDLE_TRAINERS_NUM', 1))
-trainer_id = int(os.environ.get("PADDLE_TRAINER_ID", 0))
-
-
-class ModeException(Exception):
-    """
-    ModeException
-    """
-
-    def __init__(self, message='', mode=''):
-        message += "\nOnly the following 3 modes are supported: " \
-            "train, valid, test. Given mode is {}".format(mode)
-        super(ModeException, self).__init__(message)
-
-
-class SampleNumException(Exception):
-    """
-    SampleNumException
-    """
-
-    def __init__(self, message='', sample_num=0, batch_size=1):
-        message += "\nError: The number of the whole data ({}) " \
-            "is smaller than the batch_size ({}), and drop_last " \
-            "is turnning on, so nothing  will feed in program, " \
-            "Terminated now. Please reset batch_size to a smaller " \
-            "number or feed more data!".format(sample_num, batch_size)
-        super(SampleNumException, self).__init__(message)
-
-
-class ShuffleSeedException(Exception):
-    """
-    ShuffleSeedException
-    """
-
-    def __init__(self, message=''):
-        message += "\nIf trainers_num > 1, the shuffle_seed must be set, " \
-            "because the order of batch data generated by reader " \
-            "must be the same in the respective processes."
-        super(ShuffleSeedException, self).__init__(message)
-
-
-def check_params(params):
-    """
-    check params to avoid unexpect errors
-
-    Args:
-        params(dict):
-    """
-    if 'shuffle_seed' not in params:
-        params['shuffle_seed'] = None
-
-    if trainers_num > 1 and params['shuffle_seed'] is None:
-        raise ShuffleSeedException()
-
-    data_dir = params.get('data_dir', '')
-    assert os.path.isdir(data_dir), \
-        "{} doesn't exist, please check datadir path".format(data_dir)
-
-    if params['mode'] != 'test':
-        file_list = params.get('file_list', '')
-        assert os.path.isfile(file_list), \
-            "{} doesn't exist, please check file list path".format(file_list)
-
-
-def create_file_list(params):
-    """
-    if mode is test, create the file list
-
-    Args:
-        params(dict):
-    """
-    data_dir = params.get('data_dir', '')
-    params['file_list'] = ".tmp.txt"
-    imgtype_list = {'jpg', 'bmp', 'png', 'jpeg', 'rgb', 'tif', 'tiff'}
-    with open(params['file_list'], "w") as fout:
-        tmp_file_list = os.listdir(data_dir)
-        for file_name in tmp_file_list:
-            file_path = os.path.join(data_dir, file_name)
-            if imghdr.what(file_path) not in imgtype_list:
-                continue
-            fout.write(file_name + " 0" + "\n")
-
-
-def shuffle_lines(full_lines, seed=None):
-    """
-    random shuffle lines
-    Args:
-        full_lines(list):
-        seed(int): random seed
-    """
-    if seed is not None:
-        np.random.RandomState(seed).shuffle(full_lines)
-    else:
-        np.random.shuffle(full_lines)
-
-    return full_lines
-
-
-def get_file_list(params):
-    """
-    read label list from file and shuffle the list
-
-    Args:
-        params(dict):
-    """
-    if params['mode'] == 'test':
-        create_file_list(params)
-
-    with open(params['file_list']) as flist:
-        full_lines = [line.strip() for line in flist]
-
-    if params["mode"] == "train":
-        full_lines = shuffle_lines(full_lines, seed=params['shuffle_seed'])
-
-    return full_lines
-
-
-def create_operators(params):
-    """
-    create operators based on the config
-
-    Args:
-        params(list): a dict list, used to create some operators
-    """
-    assert isinstance(params, list), ('operator config should be a list')
-    ops = []
-    for operator in params:
-        assert isinstance(operator,
-                          dict) and len(operator) == 1, "yaml format error"
-        op_name = list(operator)[0]
-        param = {} if operator[op_name] is None else operator[op_name]
-        op = getattr(imaug, op_name)(**param)
-        ops.append(op)
-
-    return ops
-
-
-def term_mp(sig_num, frame):
-    """ kill all child processes
-    """
-    pid = os.getpid()
-    pgid = os.getpgid(os.getpid())
-    logger.info("main proc {} exit, kill process group "
-                "{}".format(pid, pgid))
-    os.killpg(pgid, signal.SIGKILL)
-    return
-
-
-class CommonDataset(Dataset):
-    def __init__(self, params):
-        self.params = params
-        self.mode = params.get("mode", "train")
-        self.full_lines = get_file_list(params)
-        self.delimiter = params.get('delimiter', ' ')
-        self.ops = create_operators(params['transforms'])
-        self.num_samples = len(self.full_lines)
-        return
-
-    def __getitem__(self, idx):
-        try:
-            line = self.full_lines[idx]
-            img_path, label = line.split(self.delimiter)
-            img_path = os.path.join(self.params['data_dir'], img_path)
-            with open(img_path, 'rb') as f:
-                img = f.read()
-            return (transform(img, self.ops), int(label))
-        except Exception as e:
-            logger.error("data read faild: {}, exception info: {}".format(line,
-                                                                          e))
-            return self.__getitem__(random.randint(0, len(self)))
-
-    def __len__(self):
-        return self.num_samples
-
-
-class MultiLabelDataset(Dataset):
-    """
-    Define dataset class for multilabel image classification
-    """
-
-    def __init__(self, params):
-        self.params = params
-        self.mode = params.get("mode", "train")
-        self.full_lines = get_file_list(params)
-        self.delimiter = params.get("delimiter", "\t")
-        self.ops = create_operators(params["transforms"])
-        self.num_samples = len(self.full_lines)
-        return
-
-    def __getitem__(self, idx):
-        try:
-            line = self.full_lines[idx]
-            img_path, label_str = line.split(self.delimiter)
-            img_path = os.path.join(self.params["data_dir"], img_path)
-            with open(img_path, "rb") as f:
-                img = f.read()
-
-            labels = label_str.split(',')
-            labels = [int(i) for i in labels]
-
-            return (transform(img, self.ops),
-                    np.array(labels).astype("float32"))
-        except Exception as e:
-            logger.error("data read failed: {}, exception info: {}".format(
-                line, e))
-            return self.__getitem__(random.randint(0, len(self)))
-
-    def __len__(self):
-        return self.num_samples
-
-
-class Reader:
-    """
-    Create a reader for trainning/validate/test
-
-    Args:
-        config(dict): arguments
-        mode(str): train or val or test
-        seed(int): random seed used to generate same sequence in each trainer
-
-    Returns:
-        the specific reader
-    """
-
-    def __init__(self, config, mode='train', places=None):
-        try:
-            self.params = config[mode.upper()]
-        except KeyError:
-            raise ModeException(mode=mode)
-
-        use_mix = config.get('use_mix')
-        self.params['mode'] = mode
-        self.shuffle = mode == "train"
-
-        self.collate_fn = None
-        self.batch_ops = []
-        if use_mix and mode == "train":
-            self.batch_ops = create_operators(self.params['mix'])
-            self.collate_fn = self.mix_collate_fn
-
-        self.places = places
-        self.use_xpu = config.get("use_xpu", False)
-        self.multilabel = config.get("multilabel", False)
-
-    def mix_collate_fn(self, batch):
-        batch = transform(batch, self.batch_ops)
-        # batch each field
-        slots = []
-        for items in batch:
-            for i, item in enumerate(items):
-                if len(slots) < len(items):
-                    slots.append([item])
-                else:
-                    slots[i].append(item)
-
-        return [np.stack(slot, axis=0) for slot in slots]
-
-    def __call__(self):
-        batch_size = int(self.params['batch_size']) // trainers_num
-
-        if self.multilabel:
-            dataset = MultiLabelDataset(self.params)
-        else:
-            dataset = CommonDataset(self.params)
-        if (self.params['mode'] != "train") and self.use_xpu:
-            loader = DataLoader(
-                dataset,
-                places=self.places,
-                batch_size=batch_size,
-                drop_last=False,
-                return_list=True,
-                shuffle=False,
-                num_workers=self.params["num_workers"])
-        else:
-            is_train = self.params['mode'] == "train"
-            batch_sampler = DistributedBatchSampler(
-                dataset,
-                batch_size=batch_size,
-                shuffle=self.shuffle and is_train,
-                drop_last=is_train)
-            loader = DataLoader(
-                dataset,
-                batch_sampler=batch_sampler,
-                collate_fn=self.collate_fn if is_train else None,
-                places=self.places,
-                return_list=True,
-                num_workers=self.params["num_workers"])
-        return loader
-
-
-signal.signal(signal.SIGINT, term_mp)
-signal.signal(signal.SIGTERM, term_mp)

paddlex/ppcls/modeling/__init__.py

@@ -1,20 +0,0 @@
-#copyright (c) 2020 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 . import architectures
-from . import loss
-
-from .architectures import *
-from .loss import *
-from .utils import *

paddlex/ppcls/modeling/architectures/__init__.py

@@ -1,51 +0,0 @@
-# copyright (c) 2020 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 .resnet import ResNet18, ResNet34, ResNet50, ResNet101, ResNet152
-from .resnet_vc import ResNet18_vc, ResNet34_vc, ResNet50_vc, ResNet101_vc, ResNet152_vc
-from .resnet_vd import ResNet18_vd, ResNet34_vd, ResNet50_vd, ResNet101_vd, ResNet152_vd, ResNet200_vd
-from .resnext import ResNeXt50_32x4d, ResNeXt50_64x4d, ResNeXt101_32x4d, ResNeXt101_64x4d, ResNeXt152_32x4d, ResNeXt152_64x4d
-from .resnext_vd import ResNeXt50_vd_32x4d, ResNeXt50_vd_64x4d, ResNeXt101_vd_32x4d, ResNeXt101_vd_64x4d, ResNeXt152_vd_32x4d, ResNeXt152_vd_64x4d
-from .res2net import Res2Net50_48w_2s, Res2Net50_26w_4s, Res2Net50_14w_8s, Res2Net50_48w_2s, Res2Net50_26w_6s, Res2Net50_26w_8s, Res2Net101_26w_4s, Res2Net152_26w_4s, Res2Net200_26w_4s
-from .res2net_vd import Res2Net50_vd_48w_2s, Res2Net50_vd_26w_4s, Res2Net50_vd_14w_8s, Res2Net50_vd_48w_2s, Res2Net50_vd_26w_6s, Res2Net50_vd_26w_8s, Res2Net101_vd_26w_4s, Res2Net152_vd_26w_4s, Res2Net200_vd_26w_4s
-from .se_resnet_vd import SE_ResNet18_vd, SE_ResNet34_vd, SE_ResNet50_vd, SE_ResNet101_vd, SE_ResNet152_vd, SE_ResNet200_vd
-from .se_resnext_vd import SE_ResNeXt50_vd_32x4d, SE_ResNeXt50_vd_32x4d, SENet154_vd
-from .se_resnext import SE_ResNeXt50_32x4d, SE_ResNeXt101_32x4d, SE_ResNeXt152_64x4d
-from .dpn import DPN68, DPN92, DPN98, DPN107, DPN131
-from .densenet import DenseNet121, DenseNet161, DenseNet169, DenseNet201, DenseNet264
-from .hrnet import HRNet_W18_C, HRNet_W30_C, HRNet_W32_C, HRNet_W40_C, HRNet_W44_C, HRNet_W48_C, HRNet_W60_C, HRNet_W64_C, SE_HRNet_W18_C, SE_HRNet_W30_C, SE_HRNet_W32_C, SE_HRNet_W40_C, SE_HRNet_W44_C, SE_HRNet_W48_C, SE_HRNet_W60_C, SE_HRNet_W64_C
-from .efficientnet import EfficientNetB0, EfficientNetB1, EfficientNetB2, EfficientNetB3, EfficientNetB4, EfficientNetB5, EfficientNetB6, EfficientNetB7, EfficientNetB0_small
-from .resnest import ResNeSt50_fast_1s1x64d, ResNeSt50, ResNeSt101
-from .googlenet import GoogLeNet
-from .ghostnet import GhostNet_x0_5, GhostNet_x1_0, GhostNet_x1_3
-from .mobilenet_v1 import MobileNetV1_x0_25, MobileNetV1_x0_5, MobileNetV1_x0_75, MobileNetV1
-from .mobilenet_v2 import MobileNetV2_x0_25, MobileNetV2_x0_5, MobileNetV2_x0_75, MobileNetV2, MobileNetV2_x1_5, MobileNetV2_x2_0
-from .mobilenet_v3 import MobileNetV3_small_x0_35, MobileNetV3_small_x0_5, MobileNetV3_small_x0_75, MobileNetV3_small_x1_0, MobileNetV3_small_x1_25, MobileNetV3_large_x0_35, MobileNetV3_large_x0_5, MobileNetV3_large_x0_75, MobileNetV3_large_x1_0, MobileNetV3_large_x1_25
-from .shufflenet_v2 import ShuffleNetV2_x0_25, ShuffleNetV2_x0_33, ShuffleNetV2_x0_5, ShuffleNetV2_x1_0, ShuffleNetV2_x1_5, ShuffleNetV2_x2_0, ShuffleNetV2_swish
-from .alexnet import AlexNet
-from .inception_v3 import InceptionV3
-from .inception_v4 import InceptionV4
-from .xception import Xception41, Xception65, Xception71
-from .xception_deeplab import Xception41_deeplab, Xception65_deeplab, Xception71_deeplab
-from .resnext101_wsl import ResNeXt101_32x8d_wsl, ResNeXt101_32x16d_wsl, ResNeXt101_32x32d_wsl, ResNeXt101_32x48d_wsl
-from .squeezenet import SqueezeNet1_0, SqueezeNet1_1
-from .vgg import VGG11, VGG13, VGG16, VGG19
-from .darknet import DarkNet53
-from .regnet import RegNetX_200MF, RegNetX_4GF, RegNetX_32GF, RegNetY_200MF, RegNetY_4GF, RegNetY_32GF
-from .vision_transformer import ViT_small_patch16_224, ViT_base_patch16_224, ViT_base_patch16_384, ViT_base_patch32_384, ViT_large_patch16_224, ViT_large_patch16_384, ViT_large_patch32_384, ViT_huge_patch16_224, ViT_huge_patch32_384
-from .distilled_vision_transformer import DeiT_tiny_patch16_224, DeiT_small_patch16_224, DeiT_base_patch16_224, DeiT_tiny_distilled_patch16_224, DeiT_small_distilled_patch16_224, DeiT_base_distilled_patch16_224, DeiT_base_patch16_384, DeiT_base_distilled_patch16_384
-from .distillation_models import ResNet50_vd_distill_MobileNetV3_large_x1_0, ResNeXt101_32x16d_wsl_distill_ResNet50_vd
-from .repvgg import RepVGG_A0, RepVGG_A1, RepVGG_A2, RepVGG_B0, RepVGG_B1, RepVGG_B2, RepVGG_B3, RepVGG_B1g2, RepVGG_B1g4, RepVGG_B2g2, RepVGG_B2g4, RepVGG_B3g2, RepVGG_B3g4
-from .mixnet import MixNet_S, MixNet_M, MixNet_L
-from .rexnet import ReXNet_1_0, ReXNet_1_3, ReXNet_1_5, ReXNet_2_0, ReXNet_3_0

paddlex/ppcls/modeling/architectures/alexnet.py

@@ -1,132 +0,0 @@
-import paddle
-from paddle import ParamAttr
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle.nn import Conv2D, BatchNorm, Linear, Dropout, ReLU
-from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
-from paddle.nn.initializer import Uniform
-import math
-
-__all__ = ["AlexNet"]
-
-
-class ConvPoolLayer(nn.Layer):
-    def __init__(self,
-                 input_channels,
-                 output_channels,
-                 filter_size,
-                 stride,
-                 padding,
-                 stdv,
-                 groups=1,
-                 act=None,
-                 name=None):
-        super(ConvPoolLayer, self).__init__()
-
-        self.relu = ReLU() if act == "relu" else None
-
-        self._conv = Conv2D(
-            in_channels=input_channels,
-            out_channels=output_channels,
-            kernel_size=filter_size,
-            stride=stride,
-            padding=padding,
-            groups=groups,
-            weight_attr=ParamAttr(
-                name=name + "_weights", initializer=Uniform(-stdv, stdv)),
-            bias_attr=ParamAttr(
-                name=name + "_offset", initializer=Uniform(-stdv, stdv)))
-        self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
-
-    def forward(self, inputs):
-        x = self._conv(inputs)
-        if self.relu is not None:
-            x = self.relu(x)
-        x = self._pool(x)
-        return x
-
-
-class AlexNetDY(nn.Layer):
-    def __init__(self, class_dim=1000):
-        super(AlexNetDY, self).__init__()
-
-        stdv = 1.0 / math.sqrt(3 * 11 * 11)
-        self._conv1 = ConvPoolLayer(
-            3, 64, 11, 4, 2, stdv, act="relu", name="conv1")
-        stdv = 1.0 / math.sqrt(64 * 5 * 5)
-        self._conv2 = ConvPoolLayer(
-            64, 192, 5, 1, 2, stdv, act="relu", name="conv2")
-        stdv = 1.0 / math.sqrt(192 * 3 * 3)
-        self._conv3 = Conv2D(
-            192,
-            384,
-            3,
-            stride=1,
-            padding=1,
-            weight_attr=ParamAttr(
-                name="conv3_weights", initializer=Uniform(-stdv, stdv)),
-            bias_attr=ParamAttr(
-                name="conv3_offset", initializer=Uniform(-stdv, stdv)))
-        stdv = 1.0 / math.sqrt(384 * 3 * 3)
-        self._conv4 = Conv2D(
-            384,
-            256,
-            3,
-            stride=1,
-            padding=1,
-            weight_attr=ParamAttr(
-                name="conv4_weights", initializer=Uniform(-stdv, stdv)),
-            bias_attr=ParamAttr(
-                name="conv4_offset", initializer=Uniform(-stdv, stdv)))
-        stdv = 1.0 / math.sqrt(256 * 3 * 3)
-        self._conv5 = ConvPoolLayer(
-            256, 256, 3, 1, 1, stdv, act="relu", name="conv5")
-        stdv = 1.0 / math.sqrt(256 * 6 * 6)
-
-        self._drop1 = Dropout(p=0.5, mode="downscale_in_infer")
-        self._fc6 = Linear(
-            in_features=256 * 6 * 6,
-            out_features=4096,
-            weight_attr=ParamAttr(
-                name="fc6_weights", initializer=Uniform(-stdv, stdv)),
-            bias_attr=ParamAttr(
-                name="fc6_offset", initializer=Uniform(-stdv, stdv)))
-
-        self._drop2 = Dropout(p=0.5, mode="downscale_in_infer")
-        self._fc7 = Linear(
-            in_features=4096,
-            out_features=4096,
-            weight_attr=ParamAttr(
-                name="fc7_weights", initializer=Uniform(-stdv, stdv)),
-            bias_attr=ParamAttr(
-                name="fc7_offset", initializer=Uniform(-stdv, stdv)))
-        self._fc8 = Linear(
-            in_features=4096,
-            out_features=class_dim,
-            weight_attr=ParamAttr(
-                name="fc8_weights", initializer=Uniform(-stdv, stdv)),
-            bias_attr=ParamAttr(
-                name="fc8_offset", initializer=Uniform(-stdv, stdv)))
-
-    def forward(self, inputs):
-        x = self._conv1(inputs)
-        x = self._conv2(x)
-        x = self._conv3(x)
-        x = F.relu(x)
-        x = self._conv4(x)
-        x = F.relu(x)
-        x = self._conv5(x)
-        x = paddle.flatten(x, start_axis=1, stop_axis=-1)
-        x = self._drop1(x)
-        x = self._fc6(x)
-        x = F.relu(x)
-        x = self._drop2(x)
-        x = self._fc7(x)
-        x = F.relu(x)
-        x = self._fc8(x)
-        return x
-
-
-def AlexNet(**args):
-    model = AlexNetDY(**args)
-    return model

paddlex/ppcls/modeling/architectures/darknet.py

@@ -1,161 +0,0 @@
-import paddle
-from paddle import ParamAttr
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle.nn import Conv2D, BatchNorm, Linear, Dropout
-from paddle.nn import AdaptiveAvgPool2D, MaxPool2D, AvgPool2D
-from paddle.nn.initializer import Uniform
-import math
-
-__all__ = ["DarkNet53"]
-
-
-class ConvBNLayer(nn.Layer):
-    def __init__(self,
-                 input_channels,
-                 output_channels,
-                 filter_size,
-                 stride,
-                 padding,
-                 name=None):
-        super(ConvBNLayer, self).__init__()
-
-        self._conv = Conv2D(
-            in_channels=input_channels,
-            out_channels=output_channels,
-            kernel_size=filter_size,
-            stride=stride,
-            padding=padding,
-            weight_attr=ParamAttr(name=name + ".conv.weights"),
-            bias_attr=False)
-
-        bn_name = name + ".bn"
-        self._bn = BatchNorm(
-            num_channels=output_channels,
-            act="relu",
-            param_attr=ParamAttr(name=bn_name + ".scale"),
-            bias_attr=ParamAttr(name=bn_name + ".offset"),
-            moving_mean_name=bn_name + ".mean",
-            moving_variance_name=bn_name + ".var")
-
-    def forward(self, inputs):
-        x = self._conv(inputs)
-        x = self._bn(x)
-        return x
-
-
-class BasicBlock(nn.Layer):
-    def __init__(self, input_channels, output_channels, name=None):
-        super(BasicBlock, self).__init__()
-
-        self._conv1 = ConvBNLayer(
-            input_channels, output_channels, 1, 1, 0, name=name + ".0")
-        self._conv2 = ConvBNLayer(
-            output_channels, output_channels * 2, 3, 1, 1, name=name + ".1")
-
-    def forward(self, inputs):
-        x = self._conv1(inputs)
-        x = self._conv2(x)
-        return paddle.add(x=inputs, y=x)
-
-
-class DarkNet(nn.Layer):
-    def __init__(self, class_dim=1000):
-        super(DarkNet, self).__init__()
-
-        self.stages = [1, 2, 8, 8, 4]
-        self._conv1 = ConvBNLayer(3, 32, 3, 1, 1, name="yolo_input")
-        self._conv2 = ConvBNLayer(
-            32, 64, 3, 2, 1, name="yolo_input.downsample")
-
-        self._basic_block_01 = BasicBlock(64, 32, name="stage.0.0")
-        self._downsample_0 = ConvBNLayer(
-            64, 128, 3, 2, 1, name="stage.0.downsample")
-
-        self._basic_block_11 = BasicBlock(128, 64, name="stage.1.0")
-        self._basic_block_12 = BasicBlock(128, 64, name="stage.1.1")
-        self._downsample_1 = ConvBNLayer(
-            128, 256, 3, 2, 1, name="stage.1.downsample")
-
-        self._basic_block_21 = BasicBlock(256, 128, name="stage.2.0")
-        self._basic_block_22 = BasicBlock(256, 128, name="stage.2.1")
-        self._basic_block_23 = BasicBlock(256, 128, name="stage.2.2")
-        self._basic_block_24 = BasicBlock(256, 128, name="stage.2.3")
-        self._basic_block_25 = BasicBlock(256, 128, name="stage.2.4")
-        self._basic_block_26 = BasicBlock(256, 128, name="stage.2.5")
-        self._basic_block_27 = BasicBlock(256, 128, name="stage.2.6")
-        self._basic_block_28 = BasicBlock(256, 128, name="stage.2.7")
-        self._downsample_2 = ConvBNLayer(
-            256, 512, 3, 2, 1, name="stage.2.downsample")
-
-        self._basic_block_31 = BasicBlock(512, 256, name="stage.3.0")
-        self._basic_block_32 = BasicBlock(512, 256, name="stage.3.1")
-        self._basic_block_33 = BasicBlock(512, 256, name="stage.3.2")
-        self._basic_block_34 = BasicBlock(512, 256, name="stage.3.3")
-        self._basic_block_35 = BasicBlock(512, 256, name="stage.3.4")
-        self._basic_block_36 = BasicBlock(512, 256, name="stage.3.5")
-        self._basic_block_37 = BasicBlock(512, 256, name="stage.3.6")
-        self._basic_block_38 = BasicBlock(512, 256, name="stage.3.7")
-        self._downsample_3 = ConvBNLayer(
-            512, 1024, 3, 2, 1, name="stage.3.downsample")
-
-        self._basic_block_41 = BasicBlock(1024, 512, name="stage.4.0")
-        self._basic_block_42 = BasicBlock(1024, 512, name="stage.4.1")
-        self._basic_block_43 = BasicBlock(1024, 512, name="stage.4.2")
-        self._basic_block_44 = BasicBlock(1024, 512, name="stage.4.3")
-
-        self._pool = AdaptiveAvgPool2D(1)
-
-        stdv = 1.0 / math.sqrt(1024.0)
-        self._out = Linear(
-            1024,
-            class_dim,
-            weight_attr=ParamAttr(
-                name="fc_weights", initializer=Uniform(-stdv, stdv)),
-            bias_attr=ParamAttr(name="fc_offset"))
-
-    def forward(self, inputs):
-        x = self._conv1(inputs)
-        x = self._conv2(x)
-
-        x = self._basic_block_01(x)
-        x = self._downsample_0(x)
-
-        x = self._basic_block_11(x)
-        x = self._basic_block_12(x)
-        x = self._downsample_1(x)
-
-        x = self._basic_block_21(x)
-        x = self._basic_block_22(x)
-        x = self._basic_block_23(x)
-        x = self._basic_block_24(x)
-        x = self._basic_block_25(x)
-        x = self._basic_block_26(x)
-        x = self._basic_block_27(x)
-        x = self._basic_block_28(x)
-        x = self._downsample_2(x)
-
-        x = self._basic_block_31(x)
-        x = self._basic_block_32(x)
-        x = self._basic_block_33(x)
-        x = self._basic_block_34(x)
-        x = self._basic_block_35(x)
-        x = self._basic_block_36(x)
-        x = self._basic_block_37(x)
-        x = self._basic_block_38(x)
-        x = self._downsample_3(x)
-
-        x = self._basic_block_41(x)
-        x = self._basic_block_42(x)
-        x = self._basic_block_43(x)
-        x = self._basic_block_44(x)
-
-        x = self._pool(x)
-        x = paddle.squeeze(x, axis=[2, 3])
-        x = self._out(x)
-        return x
-
-
-def DarkNet53(**args):
-    model = DarkNet(**args)
-    return model