dyning
GitHub
commit
b14207f3b7
|
|
@ -12,4 +12,4 @@
|
|||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
from .resnet import *
|
||||
from .resnet_name import *
|
||||
|
|
|
|||
|
|
@ -0,0 +1,213 @@
|
|||
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)
|
||||
|
|
@ -17,10 +17,8 @@ import argparse
|
|||
import numpy as np
|
||||
|
||||
import paddle.fluid as fluid
|
||||
|
||||
from ppcls.modeling import architectures
|
||||
|
||||
|
||||
def parse_args():
|
||||
def str2bool(v):
|
||||
return v.lower() in ("true", "t", "1")
|
||||
|
|
@ -33,41 +31,6 @@ def parse_args():
|
|||
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def create_predictor(args):
|
||||
def create_input():
|
||||
image = fluid.data(
|
||||
name='image', shape=[None, 3, 224, 224], dtype='float32')
|
||||
return image
|
||||
|
||||
def create_model(args, model, input, class_dim=1000):
|
||||
if args.model == "GoogLeNet":
|
||||
out, _, _ = model.net(input=input, class_dim=class_dim)
|
||||
else:
|
||||
out = model.net(input=input, class_dim=class_dim)
|
||||
out = fluid.layers.softmax(out)
|
||||
return out
|
||||
|
||||
model = architectures.__dict__[args.model]()
|
||||
|
||||
place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
|
||||
exe = fluid.Executor(place)
|
||||
|
||||
startup_prog = fluid.Program()
|
||||
infer_prog = fluid.Program()
|
||||
|
||||
with fluid.program_guard(infer_prog, startup_prog):
|
||||
with fluid.unique_name.guard():
|
||||
image = create_input()
|
||||
out = create_model(args, model, image)
|
||||
|
||||
infer_prog = infer_prog.clone(for_test=True)
|
||||
fluid.load(
|
||||
program=infer_prog, model_path=args.pretrained_model, executor=exe)
|
||||
|
||||
return exe, infer_prog, [image.name], [out.name]
|
||||
|
||||
|
||||
def create_operators():
|
||||
size = 224
|
||||
img_mean = [0.485, 0.456, 0.406]
|
||||
|
|
@ -102,19 +65,33 @@ def postprocess(outputs, topk=5):
|
|||
def main():
|
||||
args = parse_args()
|
||||
operators = create_operators()
|
||||
exe, program, feed_names, fetch_names = create_predictor(args)
|
||||
|
||||
data = preprocess(args.image_file, operators)
|
||||
data = np.expand_dims(data, axis=0)
|
||||
outputs = exe.run(program,
|
||||
feed={feed_names[0]: data},
|
||||
fetch_list=fetch_names,
|
||||
return_numpy=False)
|
||||
# assign the place
|
||||
gpu_id = fluid.dygraph.parallel.Env().dev_id
|
||||
place = fluid.CUDAPlace(gpu_id)
|
||||
|
||||
pre_weights_dict = fluid.load_program_state(args.pretrained_model)
|
||||
with fluid.dygraph.guard(place):
|
||||
net = architectures.__dict__[args.model]()
|
||||
data = preprocess(args.image_file, operators)
|
||||
data = np.expand_dims(data, axis=0)
|
||||
data = fluid.dygraph.to_variable(data)
|
||||
dy_weights_dict = net.state_dict()
|
||||
pre_weights_dict_new = {}
|
||||
for key in dy_weights_dict:
|
||||
weights_name = dy_weights_dict[key].name
|
||||
pre_weights_dict_new[key] = pre_weights_dict[weights_name]
|
||||
net.set_dict(pre_weights_dict_new)
|
||||
net.eval()
|
||||
outputs = net(data)
|
||||
outputs = fluid.layers.softmax(outputs)
|
||||
outputs = outputs.numpy()
|
||||
|
||||
probs = postprocess(outputs)
|
||||
|
||||
rank = 1
|
||||
for idx, prob in probs:
|
||||
print("class id: {:d}, probability: {:.4f}".format(idx, prob))
|
||||
|
||||
print("top{:d}, class id: {:d}, probability: {:.4f}".format(
|
||||
rank, idx, prob))
|
||||
rank += 1
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
|
|
|||
Loading…
Reference in New Issue