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

paddlex/ppcls/modeling/architectures/shufflenet_v2.py

@@ -1,320 +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 __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import paddle
-from paddle import ParamAttr, reshape, transpose, concat, split
-from paddle.nn import Layer, Conv2D, MaxPool2D, AdaptiveAvgPool2D, BatchNorm, Linear
-from paddle.nn.initializer import KaimingNormal
-from paddle.nn.functional import swish
-
-__all__ = [
-    "ShuffleNetV2_x0_25", "ShuffleNetV2_x0_33", "ShuffleNetV2_x0_5",
-    "ShuffleNetV2_x1_0", "ShuffleNetV2_x1_5", "ShuffleNetV2_x2_0",
-    "ShuffleNetV2_swish"
-]
-
-
-def channel_shuffle(x, groups):
-    batch_size, num_channels, height, width = x.shape[0:4]
-    channels_per_group = num_channels // groups
-
-    # reshape
-    x = reshape(
-        x=x, shape=[batch_size, groups, channels_per_group, height, width])
-
-    # transpose
-    x = transpose(x=x, perm=[0, 2, 1, 3, 4])
-
-    # flatten
-    x = reshape(x=x, shape=[batch_size, num_channels, height, width])
-    return x
-
-
-class ConvBNLayer(Layer):
-    def __init__(
-            self,
-            in_channels,
-            out_channels,
-            kernel_size,
-            stride,
-            padding,
-            groups=1,
-            act=None,
-            name=None, ):
-        super(ConvBNLayer, self).__init__()
-        self._conv = Conv2D(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            groups=groups,
-            weight_attr=ParamAttr(
-                initializer=KaimingNormal(), name=name + "_weights"),
-            bias_attr=False)
-
-        self._batch_norm = BatchNorm(
-            out_channels,
-            param_attr=ParamAttr(name=name + "_bn_scale"),
-            bias_attr=ParamAttr(name=name + "_bn_offset"),
-            act=act,
-            moving_mean_name=name + "_bn_mean",
-            moving_variance_name=name + "_bn_variance")
-
-    def forward(self, inputs):
-        y = self._conv(inputs)
-        y = self._batch_norm(y)
-        return y
-
-
-class InvertedResidual(Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 stride,
-                 act="relu",
-                 name=None):
-        super(InvertedResidual, self).__init__()
-        self._conv_pw = ConvBNLayer(
-            in_channels=in_channels // 2,
-            out_channels=out_channels // 2,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            groups=1,
-            act=act,
-            name='stage_' + name + '_conv1')
-        self._conv_dw = ConvBNLayer(
-            in_channels=out_channels // 2,
-            out_channels=out_channels // 2,
-            kernel_size=3,
-            stride=stride,
-            padding=1,
-            groups=out_channels // 2,
-            act=None,
-            name='stage_' + name + '_conv2')
-        self._conv_linear = ConvBNLayer(
-            in_channels=out_channels // 2,
-            out_channels=out_channels // 2,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            groups=1,
-            act=act,
-            name='stage_' + name + '_conv3')
-
-    def forward(self, inputs):
-        x1, x2 = split(
-            inputs,
-            num_or_sections=[inputs.shape[1] // 2, inputs.shape[1] // 2],
-            axis=1)
-        x2 = self._conv_pw(x2)
-        x2 = self._conv_dw(x2)
-        x2 = self._conv_linear(x2)
-        out = concat([x1, x2], axis=1)
-        return channel_shuffle(out, 2)
-
-
-class InvertedResidualDS(Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 stride,
-                 act="relu",
-                 name=None):
-        super(InvertedResidualDS, self).__init__()
-
-        # branch1
-        self._conv_dw_1 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=in_channels,
-            kernel_size=3,
-            stride=stride,
-            padding=1,
-            groups=in_channels,
-            act=None,
-            name='stage_' + name + '_conv4')
-        self._conv_linear_1 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=out_channels // 2,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            groups=1,
-            act=act,
-            name='stage_' + name + '_conv5')
-        # branch2
-        self._conv_pw_2 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=out_channels // 2,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            groups=1,
-            act=act,
-            name='stage_' + name + '_conv1')
-        self._conv_dw_2 = ConvBNLayer(
-            in_channels=out_channels // 2,
-            out_channels=out_channels // 2,
-            kernel_size=3,
-            stride=stride,
-            padding=1,
-            groups=out_channels // 2,
-            act=None,
-            name='stage_' + name + '_conv2')
-        self._conv_linear_2 = ConvBNLayer(
-            in_channels=out_channels // 2,
-            out_channels=out_channels // 2,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            groups=1,
-            act=act,
-            name='stage_' + name + '_conv3')
-
-    def forward(self, inputs):
-        x1 = self._conv_dw_1(inputs)
-        x1 = self._conv_linear_1(x1)
-        x2 = self._conv_pw_2(inputs)
-        x2 = self._conv_dw_2(x2)
-        x2 = self._conv_linear_2(x2)
-        out = concat([x1, x2], axis=1)
-
-        return channel_shuffle(out, 2)
-
-
-class ShuffleNet(Layer):
-    def __init__(self, class_dim=1000, scale=1.0, act="relu"):
-        super(ShuffleNet, self).__init__()
-        self.scale = scale
-        self.class_dim = class_dim
-        stage_repeats = [4, 8, 4]
-
-        if scale == 0.25:
-            stage_out_channels = [-1, 24, 24, 48, 96, 512]
-        elif scale == 0.33:
-            stage_out_channels = [-1, 24, 32, 64, 128, 512]
-        elif scale == 0.5:
-            stage_out_channels = [-1, 24, 48, 96, 192, 1024]
-        elif scale == 1.0:
-            stage_out_channels = [-1, 24, 116, 232, 464, 1024]
-        elif scale == 1.5:
-            stage_out_channels = [-1, 24, 176, 352, 704, 1024]
-        elif scale == 2.0:
-            stage_out_channels = [-1, 24, 224, 488, 976, 2048]
-        else:
-            raise NotImplementedError("This scale size:[" + str(scale) +
-                                      "] is not implemented!")
-        # 1. conv1
-        self._conv1 = ConvBNLayer(
-            in_channels=3,
-            out_channels=stage_out_channels[1],
-            kernel_size=3,
-            stride=2,
-            padding=1,
-            act=act,
-            name='stage1_conv')
-        self._max_pool = MaxPool2D(kernel_size=3, stride=2, padding=1)
-
-        # 2. bottleneck sequences
-        self._block_list = []
-        for stage_id, num_repeat in enumerate(stage_repeats):
-            for i in range(num_repeat):
-                if i == 0:
-                    block = self.add_sublayer(
-                        name=str(stage_id + 2) + '_' + str(i + 1),
-                        sublayer=InvertedResidualDS(
-                            in_channels=stage_out_channels[stage_id + 1],
-                            out_channels=stage_out_channels[stage_id + 2],
-                            stride=2,
-                            act=act,
-                            name=str(stage_id + 2) + '_' + str(i + 1)))
-                else:
-                    block = self.add_sublayer(
-                        name=str(stage_id + 2) + '_' + str(i + 1),
-                        sublayer=InvertedResidual(
-                            in_channels=stage_out_channels[stage_id + 2],
-                            out_channels=stage_out_channels[stage_id + 2],
-                            stride=1,
-                            act=act,
-                            name=str(stage_id + 2) + '_' + str(i + 1)))
-                self._block_list.append(block)
-        # 3. last_conv
-        self._last_conv = ConvBNLayer(
-            in_channels=stage_out_channels[-2],
-            out_channels=stage_out_channels[-1],
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            act=act,
-            name='conv5')
-        # 4. pool
-        self._pool2d_avg = AdaptiveAvgPool2D(1)
-        self._out_c = stage_out_channels[-1]
-        # 5. fc
-        self._fc = Linear(
-            stage_out_channels[-1],
-            class_dim,
-            weight_attr=ParamAttr(name='fc6_weights'),
-            bias_attr=ParamAttr(name='fc6_offset'))
-
-    def forward(self, inputs):
-        y = self._conv1(inputs)
-        y = self._max_pool(y)
-        for inv in self._block_list:
-            y = inv(y)
-        y = self._last_conv(y)
-        y = self._pool2d_avg(y)
-        y = paddle.flatten(y, start_axis=1, stop_axis=-1)
-        y = self._fc(y)
-        return y
-
-
-def ShuffleNetV2_x0_25(**args):
-    model = ShuffleNet(scale=0.25, **args)
-    return model
-
-
-def ShuffleNetV2_x0_33(**args):
-    model = ShuffleNet(scale=0.33, **args)
-    return model
-
-
-def ShuffleNetV2_x0_5(**args):
-    model = ShuffleNet(scale=0.5, **args)
-    return model
-
-
-def ShuffleNetV2_x1_0(**args):
-    model = ShuffleNet(scale=1.0, **args)
-    return model
-
-
-def ShuffleNetV2_x1_5(**args):
-    model = ShuffleNet(scale=1.5, **args)
-    return model
-
-
-def ShuffleNetV2_x2_0(**args):
-    model = ShuffleNet(scale=2.0, **args)
-    return model
-
-
-def ShuffleNetV2_swish(**args):
-    model = ShuffleNet(scale=1.0, act="swish", **args)
-    return model

paddlex/ppcls/modeling/architectures/squeezenet.py

@@ -1,154 +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
-
-__all__ = ["SqueezeNet1_0", "SqueezeNet1_1"]
-
-
-class MakeFireConv(nn.Layer):
-    def __init__(self,
-                 input_channels,
-                 output_channels,
-                 filter_size,
-                 padding=0,
-                 name=None):
-        super(MakeFireConv, self).__init__()
-        self._conv = Conv2D(
-            input_channels,
-            output_channels,
-            filter_size,
-            padding=padding,
-            weight_attr=ParamAttr(name=name + "_weights"),
-            bias_attr=ParamAttr(name=name + "_offset"))
-
-    def forward(self, x):
-        x = self._conv(x)
-        x = F.relu(x)
-        return x
-
-
-class MakeFire(nn.Layer):
-    def __init__(self,
-                 input_channels,
-                 squeeze_channels,
-                 expand1x1_channels,
-                 expand3x3_channels,
-                 name=None):
-        super(MakeFire, self).__init__()
-        self._conv = MakeFireConv(
-            input_channels, squeeze_channels, 1, name=name + "_squeeze1x1")
-        self._conv_path1 = MakeFireConv(
-            squeeze_channels, expand1x1_channels, 1, name=name + "_expand1x1")
-        self._conv_path2 = MakeFireConv(
-            squeeze_channels,
-            expand3x3_channels,
-            3,
-            padding=1,
-            name=name + "_expand3x3")
-
-    def forward(self, inputs):
-        x = self._conv(inputs)
-        x1 = self._conv_path1(x)
-        x2 = self._conv_path2(x)
-        return paddle.concat([x1, x2], axis=1)
-
-
-class SqueezeNet(nn.Layer):
-    def __init__(self, version, class_dim=1000):
-        super(SqueezeNet, self).__init__()
-        self.version = version
-
-        if self.version == "1.0":
-            self._conv = Conv2D(
-                3,
-                96,
-                7,
-                stride=2,
-                weight_attr=ParamAttr(name="conv1_weights"),
-                bias_attr=ParamAttr(name="conv1_offset"))
-            self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
-            self._conv1 = MakeFire(96, 16, 64, 64, name="fire2")
-            self._conv2 = MakeFire(128, 16, 64, 64, name="fire3")
-            self._conv3 = MakeFire(128, 32, 128, 128, name="fire4")
-
-            self._conv4 = MakeFire(256, 32, 128, 128, name="fire5")
-            self._conv5 = MakeFire(256, 48, 192, 192, name="fire6")
-            self._conv6 = MakeFire(384, 48, 192, 192, name="fire7")
-            self._conv7 = MakeFire(384, 64, 256, 256, name="fire8")
-
-            self._conv8 = MakeFire(512, 64, 256, 256, name="fire9")
-        else:
-            self._conv = Conv2D(
-                3,
-                64,
-                3,
-                stride=2,
-                padding=1,
-                weight_attr=ParamAttr(name="conv1_weights"),
-                bias_attr=ParamAttr(name="conv1_offset"))
-            self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
-            self._conv1 = MakeFire(64, 16, 64, 64, name="fire2")
-            self._conv2 = MakeFire(128, 16, 64, 64, name="fire3")
-
-            self._conv3 = MakeFire(128, 32, 128, 128, name="fire4")
-            self._conv4 = MakeFire(256, 32, 128, 128, name="fire5")
-
-            self._conv5 = MakeFire(256, 48, 192, 192, name="fire6")
-            self._conv6 = MakeFire(384, 48, 192, 192, name="fire7")
-            self._conv7 = MakeFire(384, 64, 256, 256, name="fire8")
-            self._conv8 = MakeFire(512, 64, 256, 256, name="fire9")
-
-        self._drop = Dropout(p=0.5, mode="downscale_in_infer")
-        self._conv9 = Conv2D(
-            512,
-            class_dim,
-            1,
-            weight_attr=ParamAttr(name="conv10_weights"),
-            bias_attr=ParamAttr(name="conv10_offset"))
-        self._avg_pool = AdaptiveAvgPool2D(1)
-
-    def forward(self, inputs):
-        x = self._conv(inputs)
-        x = F.relu(x)
-        x = self._pool(x)
-        if self.version == "1.0":
-            x = self._conv1(x)
-            x = self._conv2(x)
-            x = self._conv3(x)
-            x = self._pool(x)
-            x = self._conv4(x)
-            x = self._conv5(x)
-            x = self._conv6(x)
-            x = self._conv7(x)
-            x = self._pool(x)
-            x = self._conv8(x)
-        else:
-            x = self._conv1(x)
-            x = self._conv2(x)
-            x = self._pool(x)
-            x = self._conv3(x)
-            x = self._conv4(x)
-            x = self._pool(x)
-            x = self._conv5(x)
-            x = self._conv6(x)
-            x = self._conv7(x)
-            x = self._conv8(x)
-        x = self._drop(x)
-        x = self._conv9(x)
-        x = F.relu(x)
-        x = self._avg_pool(x)
-        x = paddle.squeeze(x, axis=[2, 3])
-        return x
-
-
-def SqueezeNet1_0(**args):
-    model = SqueezeNet(version="1.0", **args)
-    return model
-
-
-def SqueezeNet1_1(**args):
-    model = SqueezeNet(version="1.1", **args)
-    return model

paddlex/ppcls/modeling/architectures/vgg.py

@@ -1,152 +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
-
-__all__ = ["VGG11", "VGG13", "VGG16", "VGG19"]
-
-
-class ConvBlock(nn.Layer):
-    def __init__(self, input_channels, output_channels, groups, name=None):
-        super(ConvBlock, self).__init__()
-
-        self.groups = groups
-        self._conv_1 = Conv2D(
-            in_channels=input_channels,
-            out_channels=output_channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            weight_attr=ParamAttr(name=name + "1_weights"),
-            bias_attr=False)
-        if groups == 2 or groups == 3 or groups == 4:
-            self._conv_2 = Conv2D(
-                in_channels=output_channels,
-                out_channels=output_channels,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                weight_attr=ParamAttr(name=name + "2_weights"),
-                bias_attr=False)
-        if groups == 3 or groups == 4:
-            self._conv_3 = Conv2D(
-                in_channels=output_channels,
-                out_channels=output_channels,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                weight_attr=ParamAttr(name=name + "3_weights"),
-                bias_attr=False)
-        if groups == 4:
-            self._conv_4 = Conv2D(
-                in_channels=output_channels,
-                out_channels=output_channels,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                weight_attr=ParamAttr(name=name + "4_weights"),
-                bias_attr=False)
-
-        self._pool = MaxPool2D(kernel_size=2, stride=2, padding=0)
-
-    def forward(self, inputs):
-        x = self._conv_1(inputs)
-        x = F.relu(x)
-        if self.groups == 2 or self.groups == 3 or self.groups == 4:
-            x = self._conv_2(x)
-            x = F.relu(x)
-        if self.groups == 3 or self.groups == 4:
-            x = self._conv_3(x)
-            x = F.relu(x)
-        if self.groups == 4:
-            x = self._conv_4(x)
-            x = F.relu(x)
-        x = self._pool(x)
-        return x
-
-
-class VGGNet(nn.Layer):
-    def __init__(self, layers=11, stop_grad_layers=0, class_dim=1000):
-        super(VGGNet, self).__init__()
-
-        self.layers = layers
-        self.stop_grad_layers = stop_grad_layers
-        self.vgg_configure = {
-            11: [1, 1, 2, 2, 2],
-            13: [2, 2, 2, 2, 2],
-            16: [2, 2, 3, 3, 3],
-            19: [2, 2, 4, 4, 4]
-        }
-        assert self.layers in self.vgg_configure.keys(), \
-            "supported layers are {} but input layer is {}".format(
-                self.vgg_configure.keys(), layers)
-        self.groups = self.vgg_configure[self.layers]
-
-        self._conv_block_1 = ConvBlock(3, 64, self.groups[0], name="conv1_")
-        self._conv_block_2 = ConvBlock(64, 128, self.groups[1], name="conv2_")
-        self._conv_block_3 = ConvBlock(128, 256, self.groups[2], name="conv3_")
-        self._conv_block_4 = ConvBlock(256, 512, self.groups[3], name="conv4_")
-        self._conv_block_5 = ConvBlock(512, 512, self.groups[4], name="conv5_")
-
-        for idx, block in enumerate([
-                self._conv_block_1, self._conv_block_2, self._conv_block_3,
-                self._conv_block_4, self._conv_block_5
-        ]):
-            if self.stop_grad_layers >= idx + 1:
-                for param in block.parameters():
-                    param.trainable = False
-
-        self._drop = Dropout(p=0.5, mode="downscale_in_infer")
-        self._fc1 = Linear(
-            7 * 7 * 512,
-            4096,
-            weight_attr=ParamAttr(name="fc6_weights"),
-            bias_attr=ParamAttr(name="fc6_offset"))
-        self._fc2 = Linear(
-            4096,
-            4096,
-            weight_attr=ParamAttr(name="fc7_weights"),
-            bias_attr=ParamAttr(name="fc7_offset"))
-        self._out = Linear(
-            4096,
-            class_dim,
-            weight_attr=ParamAttr(name="fc8_weights"),
-            bias_attr=ParamAttr(name="fc8_offset"))
-
-    def forward(self, inputs):
-        x = self._conv_block_1(inputs)
-        x = self._conv_block_2(x)
-        x = self._conv_block_3(x)
-        x = self._conv_block_4(x)
-        x = self._conv_block_5(x)
-        x = paddle.flatten(x, start_axis=1, stop_axis=-1)
-        x = self._fc1(x)
-        x = F.relu(x)
-        x = self._drop(x)
-        x = self._fc2(x)
-        x = F.relu(x)
-        x = self._drop(x)
-        x = self._out(x)
-        return x
-
-
-def VGG11(**args):
-    model = VGGNet(layers=11, **args)
-    return model
-
-
-def VGG13(**args):
-    model = VGGNet(layers=13, **args)
-    return model
-
-
-def VGG16(**args):
-    model = VGGNet(layers=16, **args)
-    return model
-
-
-def VGG19(**args):
-    model = VGGNet(layers=19, **args)
-    return model