1 /*
2 * Copyright (c) 2018-2021 Arm Limited.
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to
8 * deal in the Software without restriction, including without limitation the
9 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 * sell copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24 #include "arm_compute/graph.h"
25 #include "support/ToolchainSupport.h"
26 #include "utils/CommonGraphOptions.h"
27 #include "utils/GraphUtils.h"
28 #include "utils/Utils.h"
29
30 using namespace arm_compute::utils;
31 using namespace arm_compute::graph::frontend;
32 using namespace arm_compute::graph_utils;
33
34 /** Example demonstrating how to implement ResNetV2_50 network using the Compute Library's graph API */
35 class GraphResNetV2_50Example : public Example
36 {
37 public:
GraphResNetV2_50Example()38 GraphResNetV2_50Example()
39 : cmd_parser(), common_opts(cmd_parser), common_params(), graph(0, "ResNetV2_50")
40 {
41 }
do_setup(int argc,char ** argv)42 bool do_setup(int argc, char **argv) override
43 {
44 // Parse arguments
45 cmd_parser.parse(argc, argv);
46 cmd_parser.validate();
47
48 // Consume common parameters
49 common_params = consume_common_graph_parameters(common_opts);
50
51 // Return when help menu is requested
52 if(common_params.help)
53 {
54 cmd_parser.print_help(argv[0]);
55 return false;
56 }
57
58 // Print parameter values
59 std::cout << common_params << std::endl;
60
61 // Get trainable parameters data path
62 std::string data_path = common_params.data_path;
63 std::string model_path = "/cnn_data/resnet_v2_50_model/";
64 if(!data_path.empty())
65 {
66 data_path += model_path;
67 }
68
69 // Create a preprocessor object
70 std::unique_ptr<IPreprocessor> preprocessor = std::make_unique<TFPreproccessor>();
71
72 // Create input descriptor
73 const auto operation_layout = common_params.data_layout;
74 const TensorShape tensor_shape = permute_shape(TensorShape(224U, 224U, 3U, common_params.batches), DataLayout::NCHW, operation_layout);
75 TensorDescriptor input_descriptor = TensorDescriptor(tensor_shape, common_params.data_type).set_layout(operation_layout);
76
77 // Set weights trained layout
78 const DataLayout weights_layout = DataLayout::NCHW;
79
80 graph << common_params.target
81 << common_params.fast_math_hint
82 << InputLayer(input_descriptor, get_input_accessor(common_params, std::move(preprocessor), false /* Do not convert to BGR */))
83 << ConvolutionLayer(
84 7U, 7U, 64U,
85 get_weights_accessor(data_path, "conv1_weights.npy", weights_layout),
86 get_weights_accessor(data_path, "conv1_biases.npy", weights_layout),
87 PadStrideInfo(2, 2, 3, 3))
88 .set_name("conv1/convolution")
89 << PoolingLayer(PoolingLayerInfo(PoolingType::MAX, 3, operation_layout, PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR))).set_name("pool1/MaxPool");
90
91 add_residual_block(data_path, "block1", weights_layout, 64, 3, 2);
92 add_residual_block(data_path, "block2", weights_layout, 128, 4, 2);
93 add_residual_block(data_path, "block3", weights_layout, 256, 6, 2);
94 add_residual_block(data_path, "block4", weights_layout, 512, 3, 1);
95
96 graph << BatchNormalizationLayer(
97 get_weights_accessor(data_path, "postnorm_moving_mean.npy"),
98 get_weights_accessor(data_path, "postnorm_moving_variance.npy"),
99 get_weights_accessor(data_path, "postnorm_gamma.npy"),
100 get_weights_accessor(data_path, "postnorm_beta.npy"),
101 0.000009999999747378752f)
102 .set_name("postnorm/BatchNorm")
103 << ActivationLayer(ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU)).set_name("postnorm/Relu")
104 << PoolingLayer(PoolingLayerInfo(PoolingType::AVG, operation_layout)).set_name("pool5")
105 << ConvolutionLayer(
106 1U, 1U, 1001U,
107 get_weights_accessor(data_path, "logits_weights.npy", weights_layout),
108 get_weights_accessor(data_path, "logits_biases.npy"),
109 PadStrideInfo(1, 1, 0, 0))
110 .set_name("logits/convolution")
111 << FlattenLayer().set_name("predictions/Reshape")
112 << SoftmaxLayer().set_name("predictions/Softmax")
113 << OutputLayer(get_output_accessor(common_params, 5));
114
115 // Finalize graph
116 GraphConfig config;
117 config.num_threads = common_params.threads;
118 config.use_tuner = common_params.enable_tuner;
119 config.tuner_mode = common_params.tuner_mode;
120 config.tuner_file = common_params.tuner_file;
121 config.mlgo_file = common_params.mlgo_file;
122 config.use_synthetic_type = arm_compute::is_data_type_quantized(common_params.data_type);
123 config.synthetic_type = common_params.data_type;
124
125 graph.finalize(common_params.target, config);
126
127 return true;
128 }
129
do_run()130 void do_run() override
131 {
132 // Run graph
133 graph.run();
134 }
135
136 private:
137 CommandLineParser cmd_parser;
138 CommonGraphOptions common_opts;
139 CommonGraphParams common_params;
140 Stream graph;
141
add_residual_block(const std::string & data_path,const std::string & name,DataLayout weights_layout,unsigned int base_depth,unsigned int num_units,unsigned int stride)142 void add_residual_block(const std::string &data_path, const std::string &name, DataLayout weights_layout,
143 unsigned int base_depth, unsigned int num_units, unsigned int stride)
144 {
145 for(unsigned int i = 0; i < num_units; ++i)
146 {
147 // Generate unit names
148 std::stringstream unit_path_ss;
149 unit_path_ss << name << "_unit_" << (i + 1) << "_bottleneck_v2_";
150 std::stringstream unit_name_ss;
151 unit_name_ss << name << "/unit" << (i + 1) << "/bottleneck_v2/";
152
153 std::string unit_path = unit_path_ss.str();
154 std::string unit_name = unit_name_ss.str();
155
156 const TensorShape last_shape = graph.graph().node(graph.tail_node())->output(0)->desc().shape;
157 unsigned int depth_in = last_shape[arm_compute::get_data_layout_dimension_index(common_params.data_layout, DataLayoutDimension::CHANNEL)];
158 unsigned int depth_out = base_depth * 4;
159
160 // All units have stride 1 apart from last one
161 unsigned int middle_stride = (i == (num_units - 1)) ? stride : 1;
162
163 // Preact
164 SubStream preact(graph);
165 preact << BatchNormalizationLayer(
166 get_weights_accessor(data_path, unit_path + "preact_moving_mean.npy"),
167 get_weights_accessor(data_path, unit_path + "preact_moving_variance.npy"),
168 get_weights_accessor(data_path, unit_path + "preact_gamma.npy"),
169 get_weights_accessor(data_path, unit_path + "preact_beta.npy"),
170 0.000009999999747378752f)
171 .set_name(unit_name + "preact/BatchNorm")
172 << ActivationLayer(ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU)).set_name(unit_name + "preact/Relu");
173
174 // Create bottleneck path
175 SubStream shortcut(graph);
176 if(depth_in == depth_out)
177 {
178 if(middle_stride != 1)
179 {
180 shortcut << PoolingLayer(PoolingLayerInfo(PoolingType::MAX, 1, common_params.data_layout, PadStrideInfo(middle_stride, middle_stride, 0, 0), true)).set_name(unit_name + "shortcut/MaxPool");
181 }
182 }
183 else
184 {
185 shortcut.forward_tail(preact.tail_node());
186 shortcut << ConvolutionLayer(
187 1U, 1U, depth_out,
188 get_weights_accessor(data_path, unit_path + "shortcut_weights.npy", weights_layout),
189 get_weights_accessor(data_path, unit_path + "shortcut_biases.npy", weights_layout),
190 PadStrideInfo(1, 1, 0, 0))
191 .set_name(unit_name + "shortcut/convolution");
192 }
193
194 // Create residual path
195 SubStream residual(preact);
196 residual << ConvolutionLayer(
197 1U, 1U, base_depth,
198 get_weights_accessor(data_path, unit_path + "conv1_weights.npy", weights_layout),
199 std::unique_ptr<arm_compute::graph::ITensorAccessor>(nullptr),
200 PadStrideInfo(1, 1, 0, 0))
201 .set_name(unit_name + "conv1/convolution")
202 << BatchNormalizationLayer(
203 get_weights_accessor(data_path, unit_path + "conv1_BatchNorm_moving_mean.npy"),
204 get_weights_accessor(data_path, unit_path + "conv1_BatchNorm_moving_variance.npy"),
205 get_weights_accessor(data_path, unit_path + "conv1_BatchNorm_gamma.npy"),
206 get_weights_accessor(data_path, unit_path + "conv1_BatchNorm_beta.npy"),
207 0.000009999999747378752f)
208 .set_name(unit_name + "conv1/BatchNorm")
209 << ActivationLayer(ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU)).set_name(unit_name + "conv1/Relu")
210 << ConvolutionLayer(
211 3U, 3U, base_depth,
212 get_weights_accessor(data_path, unit_path + "conv2_weights.npy", weights_layout),
213 std::unique_ptr<arm_compute::graph::ITensorAccessor>(nullptr),
214 PadStrideInfo(middle_stride, middle_stride, 1, 1))
215 .set_name(unit_name + "conv2/convolution")
216 << BatchNormalizationLayer(
217 get_weights_accessor(data_path, unit_path + "conv2_BatchNorm_moving_mean.npy"),
218 get_weights_accessor(data_path, unit_path + "conv2_BatchNorm_moving_variance.npy"),
219 get_weights_accessor(data_path, unit_path + "conv2_BatchNorm_gamma.npy"),
220 get_weights_accessor(data_path, unit_path + "conv2_BatchNorm_beta.npy"),
221 0.000009999999747378752f)
222 .set_name(unit_name + "conv2/BatchNorm")
223 << ActivationLayer(ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU)).set_name(unit_name + "conv1/Relu")
224 << ConvolutionLayer(
225 1U, 1U, depth_out,
226 get_weights_accessor(data_path, unit_path + "conv3_weights.npy", weights_layout),
227 get_weights_accessor(data_path, unit_path + "conv3_biases.npy", weights_layout),
228 PadStrideInfo(1, 1, 0, 0))
229 .set_name(unit_name + "conv3/convolution");
230
231 graph << EltwiseLayer(std::move(shortcut), std::move(residual), EltwiseOperation::Add).set_name(unit_name + "add");
232 }
233 }
234 };
235
236 /** Main program for ResNetV2_50
237 *
238 * Model is based on:
239 * https://arxiv.org/abs/1603.05027
240 * "Identity Mappings in Deep Residual Networks"
241 * Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
242 *
243 * Provenance: download.tensorflow.org/models/resnet_v2_50_2017_04_14.tar.gz
244 *
245 * @note To list all the possible arguments execute the binary appended with the --help option
246 *
247 * @param[in] argc Number of arguments
248 * @param[in] argv Arguments
249 */
main(int argc,char ** argv)250 int main(int argc, char **argv)
251 {
252 return arm_compute::utils::run_example<GraphResNetV2_50Example>(argc, argv);
253 }
254