214 lines
6.5 KiB
Python
214 lines
6.5 KiB
Python
import numpy as np
|
|
import argparse
|
|
import ast
|
|
import paddle
|
|
import paddle.fluid as fluid
|
|
from paddle.fluid.param_attr import ParamAttr
|
|
from paddle.fluid.layer_helper import LayerHelper
|
|
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
|
|
from paddle.fluid.dygraph.base import to_variable
|
|
|
|
from paddle.fluid import framework
|
|
|
|
import math
|
|
import sys
|
|
import time
|
|
|
|
class ConvBNLayer(fluid.dygraph.Layer):
|
|
def __init__(self,
|
|
num_channels,
|
|
num_filters,
|
|
filter_size,
|
|
stride=1,
|
|
groups=1,
|
|
act=None,
|
|
name=None):
|
|
super(ConvBNLayer, self).__init__()
|
|
|
|
self._conv = Conv2D(
|
|
num_channels=num_channels,
|
|
num_filters=num_filters,
|
|
filter_size=filter_size,
|
|
stride=stride,
|
|
padding=(filter_size - 1) // 2,
|
|
groups=groups,
|
|
act=None,
|
|
param_attr=ParamAttr(name=name + "_weights"),
|
|
bias_attr=False)
|
|
if name == "conv1":
|
|
bn_name = "bn_" + name
|
|
else:
|
|
bn_name = "bn" + name[3:]
|
|
self._batch_norm = BatchNorm(num_filters,
|
|
act=act,
|
|
param_attr=ParamAttr(name=bn_name + '_scale'),
|
|
bias_attr=ParamAttr(bn_name + '_offset'),
|
|
moving_mean_name=bn_name + '_mean',
|
|
moving_variance_name=bn_name + '_variance')
|
|
|
|
def forward(self, inputs):
|
|
y = self._conv(inputs)
|
|
y = self._batch_norm(y)
|
|
return y
|
|
|
|
|
|
class BottleneckBlock(fluid.dygraph.Layer):
|
|
def __init__(self,
|
|
num_channels,
|
|
num_filters,
|
|
stride,
|
|
shortcut=True,
|
|
name=None):
|
|
super(BottleneckBlock, self).__init__()
|
|
|
|
self.conv0 = ConvBNLayer(
|
|
num_channels=num_channels,
|
|
num_filters=num_filters,
|
|
filter_size=1,
|
|
act='relu',
|
|
name=name+"_branch2a")
|
|
self.conv1 = ConvBNLayer(
|
|
num_channels=num_filters,
|
|
num_filters=num_filters,
|
|
filter_size=3,
|
|
stride=stride,
|
|
act='relu',
|
|
name=name+"_branch2b")
|
|
self.conv2 = ConvBNLayer(
|
|
num_channels=num_filters,
|
|
num_filters=num_filters * 4,
|
|
filter_size=1,
|
|
act=None,
|
|
name=name+"_branch2c")
|
|
|
|
if not shortcut:
|
|
self.short = ConvBNLayer(
|
|
num_channels=num_channels,
|
|
num_filters=num_filters * 4,
|
|
filter_size=1,
|
|
stride=stride,
|
|
name=name + "_branch1")
|
|
|
|
self.shortcut = shortcut
|
|
|
|
self._num_channels_out = num_filters * 4
|
|
|
|
def forward(self, inputs):
|
|
y = self.conv0(inputs)
|
|
conv1 = self.conv1(y)
|
|
conv2 = self.conv2(conv1)
|
|
|
|
if self.shortcut:
|
|
short = inputs
|
|
else:
|
|
short = self.short(inputs)
|
|
|
|
y = fluid.layers.elementwise_add(x=short, y=conv2)
|
|
|
|
layer_helper = LayerHelper(self.full_name(), act='relu')
|
|
return layer_helper.append_activation(y)
|
|
|
|
|
|
class ResNet(fluid.dygraph.Layer):
|
|
def __init__(self, layers=50, class_dim=1000):
|
|
super(ResNet, self).__init__()
|
|
|
|
self.layers = layers
|
|
supported_layers = [50, 101, 152]
|
|
assert layers in supported_layers, \
|
|
"supported layers are {} but input layer is {}".format(supported_layers, layers)
|
|
|
|
if layers == 50:
|
|
depth = [3, 4, 6, 3]
|
|
elif layers == 101:
|
|
depth = [3, 4, 23, 3]
|
|
elif layers == 152:
|
|
depth = [3, 8, 36, 3]
|
|
num_channels = [64, 256, 512, 1024]
|
|
num_filters = [64, 128, 256, 512]
|
|
|
|
self.conv = ConvBNLayer(
|
|
num_channels=3,
|
|
num_filters=64,
|
|
filter_size=7,
|
|
stride=2,
|
|
act='relu',
|
|
name="conv1")
|
|
self.pool2d_max = Pool2D(
|
|
pool_size=3,
|
|
pool_stride=2,
|
|
pool_padding=1,
|
|
pool_type='max')
|
|
|
|
self.bottleneck_block_list = []
|
|
for block in range(len(depth)):
|
|
shortcut = False
|
|
for i in range(depth[block]):
|
|
if layers in [101, 152] and block == 2:
|
|
if i == 0:
|
|
conv_name="res"+str(block+2)+"a"
|
|
else:
|
|
conv_name="res"+str(block+2)+"b"+str(i)
|
|
else:
|
|
conv_name="res"+str(block+2)+chr(97+i)
|
|
bottleneck_block = self.add_sublayer(
|
|
'bb_%d_%d' % (block, i),
|
|
BottleneckBlock(
|
|
num_channels=num_channels[block]
|
|
if i == 0 else num_filters[block] * 4,
|
|
num_filters=num_filters[block],
|
|
stride=2 if i == 0 and block != 0 else 1,
|
|
shortcut=shortcut,
|
|
name=conv_name))
|
|
self.bottleneck_block_list.append(bottleneck_block)
|
|
shortcut = True
|
|
|
|
self.pool2d_avg = Pool2D(
|
|
pool_size=7, pool_type='avg', global_pooling=True)
|
|
|
|
self.pool2d_avg_output = num_filters[len(num_filters) - 1] * 4 * 1 * 1
|
|
|
|
stdv = 1.0 / math.sqrt(2048 * 1.0)
|
|
|
|
self.out = Linear(self.pool2d_avg_output,
|
|
class_dim,
|
|
param_attr=ParamAttr(
|
|
initializer=fluid.initializer.Uniform(-stdv, stdv), name="fc_0.w_0"),
|
|
bias_attr=ParamAttr(name="fc_0.b_0"))
|
|
|
|
def forward(self, inputs):
|
|
y = self.conv(inputs)
|
|
y = self.pool2d_max(y)
|
|
for bottleneck_block in self.bottleneck_block_list:
|
|
y = bottleneck_block(y)
|
|
y = self.pool2d_avg(y)
|
|
y = fluid.layers.reshape(y, shape=[-1, self.pool2d_avg_output])
|
|
y = self.out(y)
|
|
return y
|
|
|
|
|
|
def ResNet50(**args):
|
|
model = ResNet(layers=50, **args)
|
|
return model
|
|
|
|
|
|
def ResNet101(**args):
|
|
model = ResNet(layers=101, **args)
|
|
return model
|
|
|
|
|
|
def ResNet152(**args):
|
|
model = ResNet(layers=152, **args)
|
|
return model
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import numpy as np
|
|
place = fluid.CPUPlace()
|
|
with fluid.dygraph.guard(place):
|
|
model = ResNet50()
|
|
img = np.random.uniform(0, 255, [1, 3, 224, 224]).astype('float32')
|
|
img = fluid.dygraph.to_variable(img)
|
|
res = model(img)
|
|
print(res.shape)
|