-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathsqueezenet_prun_a.py
122 lines (116 loc) · 5.92 KB
/
squeezenet_prun_a.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#copyright (c) 2019 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
import paddle.fluid as fluid
import math
from paddle.fluid.param_attr import ParamAttr
# SqueezeNet_v1.1_prun_a
# https://github.com/forresti/SqueezeNet/tree/master/SqueezeNet_v1.1
# Note: Tiny modification is made: each conv layer is followed by a BN layer.
#
# For simple vision classfication job, a slimmer net is required. So, this "prun_a" version
# shrink the channel width of each conv layer.
class SqueezeNetPrunA():
def net(self, input, class_dim=1000):
conv_1 = fluid.layers.conv2d(
input,
num_filters=32,
filter_size=3,
stride=2,
padding=1,
param_attr=fluid.ParamAttr(name='conv1_w', initializer=fluid.initializer.Normal(loc=0.0, scale=1.0)),
bias_attr=ParamAttr(name='conv1_b'))
conv1_bn_w_attr = fluid.ParamAttr(name='conv1_bn_w', initializer=fluid.initializer.Xavier(uniform=False))
conv1_bn_b_attr = fluid.ParamAttr(name='conv1_bn_b', initializer=fluid.initializer.Xavier(uniform=False))
conv1_bn = fluid.layers.batch_norm(input=conv_1, param_attr=conv1_bn_w_attr, bias_attr=conv1_bn_b_attr)
conv1_bn_relu = fluid.layers.relu(conv1_bn, name='conv1_bn_relu')
pool_1 = fluid.layers.pool2d(
conv1_bn_relu, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max')
conv = self.make_fire(pool_1, 8, 32, 32, name='fire2')
conv = self.make_fire(conv, 8, 32, 32, name='fire3')
pool_2 = fluid.layers.pool2d(
conv, pool_size=3, pool_stride=2, pool_type='max')
conv = self.make_fire(pool_2, 16, 64, 64, name='fire4')
conv = self.make_fire(conv, 16, 64, 64, name='fire5')
pool_3 = fluid.layers.pool2d(
conv, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max')
conv = self.make_fire(pool_3, 24, 96, 96, name='fire6')
conv = self.make_fire(conv, 24, 96, 96, name='fire7')
conv = self.make_fire(conv, 32, 128, 128, name='fire8')
conv = self.make_fire(conv, 32, 128, 128, name='fire9')
conv = fluid.layers.dropout(conv, dropout_prob=0.5)
conv = fluid.layers.conv2d(
conv,
num_filters=class_dim,
filter_size=1,
param_attr=fluid.ParamAttr(name='conv10_w', initializer=fluid.initializer.Normal(loc=0.0, scale=1.0)),
bias_attr=ParamAttr(name='conv10_b'))
conv10_bn_w_attr = fluid.ParamAttr(name='conv10_bn_w', initializer=fluid.initializer.Xavier(uniform=False))
conv10_bn_b_attr = fluid.ParamAttr(name='conv10_bn_b', initializer=fluid.initializer.Xavier(uniform=False))
conv10_bn = fluid.layers.batch_norm(input=conv, param_attr=conv10_bn_w_attr, bias_attr=conv10_bn_b_attr)
conv10_bn_relu = fluid.layers.relu(conv10_bn, name='conv1_bn_relu')
pool_4 = fluid.layers.pool2d(conv10_bn_relu, pool_type='avg', global_pooling=True)
pool_4_flat = fluid.layers.flatten(pool_4)
out = fluid.layers.softmax(input=pool_4_flat)
return out, conv
def make_fire_conv_bn(self,
input,
num_filters,
filter_size,
padding=0,
name=None):
conv_attr = fluid.ParamAttr(name=name + '_w', initializer=fluid.initializer.Normal(loc=0.0, scale=1.0))
conv = fluid.layers.conv2d(
input,
num_filters=num_filters,
filter_size=filter_size,
padding=padding,
param_attr=conv_attr,
bias_attr=ParamAttr(name=name + '_b'))
bn_w_attr = fluid.ParamAttr(name=name + '_bn_w', initializer=fluid.initializer.Xavier(uniform=False))
bn_b_attr = fluid.ParamAttr(name=name + '_bn_b', initializer=fluid.initializer.Xavier(uniform=False))
conv = fluid.layers.batch_norm(input=conv, param_attr=bn_w_attr, bias_attr=bn_b_attr)
conv = fluid.layers.relu(conv, name=name + '_bn_relu')
return conv
def make_fire(self,
input,
squeeze_channels,
expand1x1_channels,
expand3x3_channels,
name=None):
conv = self.make_fire_conv_bn(
input, squeeze_channels, 1, name=name + '_squeeze1x1')
conv_path1 = self.make_fire_conv_bn(
conv, expand1x1_channels, 1, name=name + '_expand1x1')
conv_path2 = self.make_fire_conv_bn(
conv, expand3x3_channels, 3, 1, name=name + '_expand3x3')
out = fluid.layers.concat([conv_path1, conv_path2], axis=1)
return out
if __name__ == '__main__':
model = SqueezeNetPrunA()
image = fluid.layers.data(name='image', shape=[1, 112, 112], dtype='float32')
net, layer = model.net(image,2)
print("model output shape:")
print(net.shape)
print(layer.shape)
exe = fluid.Executor(fluid.CPUPlace())
exe.run(fluid.default_startup_program())
model_path = "./model/squeezenet_prun_a/0"
fluid.io.save_inference_model(dirname=model_path, feeded_var_names=[image.name], target_vars=[net], executor=exe)
# To see the model graph(no tensor dimension info)
# 1.run visualdl --model_pb ./model --logdir ./ in terminal
# 2.open http://0.0.0.0:8040/static/index.html#/graphs in browser