tf_test.cpp 12.6 KB
Newer Older
1
2
3
#include <iostream>
#include <vector>
#include <migraphx/literal.hpp>
Paul's avatar
Paul committed
4
5
6
7
#include <migraphx/pass_manager.hpp>
#include <migraphx/simplify_reshapes.hpp>
#include <migraphx/dead_code_elimination.hpp>
#include <migraphx/eliminate_identity.hpp>
8
9
10
11
12
13
#include <migraphx/operators.hpp>
#include <migraphx/program.hpp>
#include <migraphx/instruction.hpp>
#include <migraphx/tf.hpp>
#include "test.hpp"

Paul's avatar
Paul committed
14
15
16
17
18
19
20
21
migraphx::program optimize_tf(const std::string& name, bool is_nhwc)
{
    auto prog = migraphx::parse_tf(name, is_nhwc);
    if (is_nhwc)
        migraphx::run_passes(prog, {migraphx::simplify_reshapes{}, migraphx::dead_code_elimination{}, migraphx::eliminate_identity{}});
    return prog;
}

22
23
24
25
26
27
TEST_CASE(add_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    p.add_instruction(migraphx::op::add{}, l0, l1);
Paul's avatar
Paul committed
28
    auto prog = optimize_tf("add_test.pb", false);
29
30
31
32
33
34

    EXPECT(p == prog);
}

TEST_CASE(add_bcast_test)
{
Khalique's avatar
Khalique committed
35

36
37
38
39
40
41
42
    migraphx::program p;
    migraphx::shape s0{migraphx::shape::float_type, {2, 3}};
    auto l0 = p.add_parameter("0", s0);
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2, 1}});
    auto l2 = p.add_instruction(migraphx::op::multibroadcast{s0.lens()}, l0);
    auto l3 = p.add_instruction(migraphx::op::multibroadcast{s0.lens()}, l1);
    p.add_instruction(migraphx::op::add{}, l2, l3);
Paul's avatar
Paul committed
43
    auto prog = optimize_tf("add_bcast_test.pb", false);
44
45
46
47

    EXPECT(p == prog);
}

48
49
TEST_CASE(batchnorm_test)
{
Khalique's avatar
Khalique committed
50
51
    float epsilon  = 1.001e-5f;
    float momentum = 0.9f;
52
53

    migraphx::program p;
Khalique's avatar
Khalique committed
54
55
    migraphx::op::batch_norm_inference op{
        epsilon, momentum, migraphx::op::batch_norm_inference::spatial};
56
    migraphx::shape s0{migraphx::shape::float_type, {32}};
57
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 32, 16, 16}});
58
59
    std::vector<float> const_vals(32);
    std::fill(const_vals.begin(), const_vals.end(), 1.0f);
Khalique's avatar
Khalique committed
60

61
62
63
64
65
    auto l2 = p.add_parameter("2", s0);
    auto l3 = p.add_parameter("3", s0);
    auto l4 = p.add_parameter("4", s0);
    auto l1 = p.add_literal(migraphx::literal{s0, const_vals});
    p.add_instruction(op, l0, l1, l2, l3, l4);
Paul's avatar
Paul committed
66
    auto prog = optimize_tf("batchnorm_test.pb", true);
67
68
69
70

    EXPECT(p == prog);
}

71
72
73
TEST_CASE(biasadd_test)
{
    migraphx::program p;
74
    migraphx::shape s0{migraphx::shape::float_type, {1, 500, 1, 1}};
75
    uint64_t axis = 1;
Khalique's avatar
Khalique committed
76
    auto l0       = p.add_parameter("0", s0);
77
    auto l1       = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {500}});
78
    auto l2       = p.add_instruction(migraphx::op::broadcast{axis, l0->get_shape().lens()}, l1);
79
    p.add_instruction(migraphx::op::add{}, l0, l2);
Paul's avatar
Paul committed
80
    auto prog = optimize_tf("biasadd_test.pb", true);
81
82
83
84

    EXPECT(p == prog);
}

85
86
87
TEST_CASE(concat_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
88

89
90
91
92
93
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {4, 7, 3}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 2, 3}});

    int axis = 1;
    // tf uses axis as the third input, and it is in int32 format
Khalique's avatar
Khalique committed
94
    // add the literal using a vector in order to set stride to 1 (like in tf parser)
95
    p.add_literal(migraphx::shape{migraphx::shape::int32_type}, std::vector<int>{axis});
96
97

    p.add_instruction(migraphx::op::concat{static_cast<std::size_t>(axis)}, l0, l1);
Paul's avatar
Paul committed
98
    auto prog = optimize_tf("concat_test.pb", false);
99
100
101
102
103
104
105

    EXPECT(p == prog);
}

TEST_CASE(const_test)
{
    migraphx::program p;
106
    p.add_literal(migraphx::shape{migraphx::shape::float_type}, std::vector<float>{1.0f});
Paul's avatar
Paul committed
107
    auto prog = optimize_tf("constant_test.pb", false);
108
109
110
111
112
113
114

    EXPECT(p == prog);
}

TEST_CASE(conv_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
115

116
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
Khalique's avatar
Khalique committed
117
    std::vector<float> weight_data(3 * 3 * 3 * 32);
118
    std::fill(weight_data.begin(), weight_data.end(), 1.0f);
Khalique's avatar
Khalique committed
119
120
    auto l1 =
        p.add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 32}}, weight_data);
121
122
123

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
Khalique's avatar
Khalique committed
124
125
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
Paul's avatar
Paul committed
126
127
128
    auto l2         = p.add_instruction(migraphx::op::transpose{{3, 2, 0, 1}}, l1);
    p.add_instruction(op, l0, l2);
    auto prog = optimize_tf("conv_test.pb", true);
129
130
131
132

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
TEST_CASE(depthwiseconv_test)
{
    migraphx::program p;

    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    std::vector<float> weight_data(3 * 3 * 3 * 1);
    std::fill(weight_data.begin(), weight_data.end(), 1.0f);
    auto l1 =
        p.add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 1}}, weight_data);

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
    op.group        = 3;
Paul's avatar
Paul committed
148
    auto l3         = p.add_instruction(migraphx::op::transpose{{3, 2, 0, 1}}, l1);
Paul's avatar
Paul committed
149
150
151
    auto l4         = p.add_instruction(migraphx::op::contiguous{}, l3);
    auto l5         = p.add_instruction(migraphx::op::reshape{{3, 1, 3, 3}}, l4);
    p.add_instruction(op, l0, l5);
Paul's avatar
Paul committed
152
    auto prog = optimize_tf("depthwise_conv_test.pb", true);
Khalique's avatar
Khalique committed
153
154
155
156

    EXPECT(p == prog);
}

157
158
159
160
161
TEST_CASE(identity_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    p.add_instruction(migraphx::op::identity{}, l0);
Paul's avatar
Paul committed
162
    auto prog = optimize_tf("identity_test.pb", false);
163
164
165
166

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
167
168
169
170
171
TEST_CASE(matmul_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {8, 4}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 8}});
Khalique's avatar
Khalique committed
172
173
174

    auto trans_l0 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l0);
    auto trans_l1 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l1);
Khalique's avatar
Khalique committed
175
176

    p.add_instruction(migraphx::op::dot{}, trans_l0, trans_l1);
Paul's avatar
Paul committed
177
    auto prog = optimize_tf("matmul_test.pb", false);
Khalique's avatar
Khalique committed
178
179
180
181

    EXPECT(p == prog);
}

182
183
184
TEST_CASE(mean_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
185
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {2, 3}};
186
187
188
189
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    p.add_literal(l);
    p.add_literal(l);
    migraphx::op::pooling op;
Khalique's avatar
Khalique committed
190
    op.lengths = {16, 16};
Paul's avatar
Paul committed
191
    p.add_instruction(op, l0);
Khalique's avatar
Khalique committed
192
193
    auto l3    = p.add_instruction(op, l0);
    p.add_instruction(migraphx::op::squeeze{{2, 3}}, l3);
Paul's avatar
Paul committed
194
    auto prog = optimize_tf("mean_test.pb", false);
195
196
197
198
199
200
201

    EXPECT(p == prog);
}

TEST_CASE(mean_test_nhwc)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
202
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {1, 2}};
203
204
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    migraphx::op::pooling op;
Khalique's avatar
Khalique committed
205
206
207
    op.lengths = {16, 16};
    auto l3    = p.add_instruction(op, l0);
    p.add_instruction(migraphx::op::squeeze{{2, 3}}, l3);
Paul's avatar
Paul committed
208
    auto prog = optimize_tf("mean_test_nhwc.pb", true);
209
210
211
212

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
213
214
215
TEST_CASE(mul_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
216
217
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 1, 1, 16}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 1, 16}});
Khalique's avatar
Khalique committed
218
219

    p.add_instruction(migraphx::op::mul{}, l0, l1);
Paul's avatar
Paul committed
220
    auto prog = optimize_tf("mul_test.pb", false);
Khalique's avatar
Khalique committed
221
222
223
224

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
225
226
227
228
229
230
231
232
233
234
TEST_CASE(pack_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2}});
    auto l2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {2}});
    std::vector<migraphx::instruction_ref> args{l0, l1, l2};
    std::vector<migraphx::instruction_ref> unsqueezed_args;
    int64_t axis = 1;

Khalique's avatar
Khalique committed
235
236
237
238
239
240
    std::transform(args.begin(),
                   args.end(),
                   std::back_inserter(unsqueezed_args),
                   [&](migraphx::instruction_ref arg) {
                       return p.add_instruction(migraphx::op::unsqueeze{{axis}}, arg);
                   });
Khalique's avatar
Khalique committed
241
    p.add_instruction(migraphx::op::concat{static_cast<size_t>(axis)}, unsqueezed_args);
Paul's avatar
Paul committed
242
    auto prog = optimize_tf("pack_test.pb", false);
Khalique's avatar
Khalique committed
243
244
245
246

    EXPECT(p == prog);
}

247
248
249
TEST_CASE(pack_test_nhwc)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
250
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
Paul's avatar
Paul committed
251
    auto lt0 = p.add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l0);
Khalique's avatar
Khalique committed
252
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
Paul's avatar
Paul committed
253
    auto lt1 = p.add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l1);
Khalique's avatar
Khalique committed
254
    auto l2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
Paul's avatar
Paul committed
255
256
    auto lt2 = p.add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l2);
    std::vector<migraphx::instruction_ref> args{lt0, lt1, lt2};
257
    std::vector<migraphx::instruction_ref> unsqueezed_args;
Paul's avatar
Paul committed
258
    int64_t nchw_axis = 3;
259
260
261
262
263
264
265
266

    std::transform(args.begin(),
                   args.end(),
                   std::back_inserter(unsqueezed_args),
                   [&](migraphx::instruction_ref arg) {
                       return p.add_instruction(migraphx::op::unsqueeze{{nchw_axis}}, arg);
                   });
    p.add_instruction(migraphx::op::concat{static_cast<size_t>(nchw_axis)}, unsqueezed_args);
Paul's avatar
Paul committed
267
    auto prog = optimize_tf("pack_test_nhwc.pb", true);
268
269
270
271

    EXPECT(p == prog);
}

272
273
274
TEST_CASE(pooling_test)
{
    migraphx::program p;
275
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
276
277
278
279
    migraphx::op::pooling avg_pool_op{"average"};
    migraphx::op::pooling max_pool_op{"max"};
    avg_pool_op.padding_mode = migraphx::op::padding_mode_t::valid;
    max_pool_op.padding_mode = migraphx::op::padding_mode_t::valid;
Khalique's avatar
Khalique committed
280
281
282
283
    avg_pool_op.stride       = {2, 2};
    max_pool_op.stride       = {2, 2};
    avg_pool_op.lengths      = {2, 2};
    max_pool_op.lengths      = {2, 2};
284
    p.add_instruction(max_pool_op, l0);
Paul's avatar
Paul committed
285
286
    // p.add_instruction(avg_pool_op, l0);
    auto prog = optimize_tf("pooling_test.pb", true);
287
288
289
290

    EXPECT(p == prog);
}

291
292
293
294
295
TEST_CASE(relu_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    p.add_instruction(migraphx::op::relu{}, l0);
Paul's avatar
Paul committed
296
    auto prog = optimize_tf("relu_test.pb", false);
297
298
299
300

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
301
302
303
304
305
TEST_CASE(relu6_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    p.add_instruction(migraphx::op::clip{6.0, 0.0}, l0);
Paul's avatar
Paul committed
306
    auto prog = optimize_tf("relu6_test.pb", false);
Khalique's avatar
Khalique committed
307
308
309
310

    EXPECT(p == prog);
}

311
312
313
314
315
316
TEST_CASE(reshape_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {16}});
    migraphx::shape s0{migraphx::shape::int32_type, {4}};
    // in tf, the second arg is a literal that contains new dimensions
Khalique's avatar
Khalique committed
317
318
    p.add_literal(migraphx::literal{s0, {1, 1, 1, 16}});
    p.add_instruction(migraphx::op::reshape{{1, 1, 1, 16}}, l0);
Paul's avatar
Paul committed
319
    auto prog = optimize_tf("reshape_test.pb", false);
320
321
322
323
324
325
326

    EXPECT(p == prog);
}

TEST_CASE(softmax_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
327
    auto l0   = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
328
    auto dims = l0->get_shape().lens();
Khalique's avatar
Khalique committed
329
330
    auto r    = p.add_instruction(migraphx::op::reshape{{long(dims[0]), long(dims[1]), 1, 1}}, l0);
    auto s    = p.add_instruction(migraphx::op::softmax{}, r);
331
    p.add_instruction(migraphx::op::reshape{{long(dims[0]), long(dims[1])}}, s);
Paul's avatar
Paul committed
332
    auto prog = optimize_tf("softmax_test.pb", false);
333
334
335
336
337
338
339

    EXPECT(p == prog);
}

TEST_CASE(squeeze_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
340
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 3, 1}});
341
    p.add_instruction(migraphx::op::squeeze{{0, 3}}, l0);
Paul's avatar
Paul committed
342
    auto prog = optimize_tf("squeeze_test.pb", false);
343
344
345

    EXPECT(p == prog);
}
Khalique's avatar
Khalique committed
346
347
348
349
350
351
352

TEST_CASE(stridedslice_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 10, 1, 1}});
    std::size_t num_axes = 4;
    migraphx::op::slice op;
Khalique's avatar
Khalique committed
353
    op.starts = {0, 0, 0, 0};
Paul's avatar
Paul committed
354
    op.ends   = {1, 1, 1, 5};
Khalique's avatar
Khalique committed
355
356
    op.axes   = std::vector<int64_t>(num_axes);
    std::iota(op.axes.begin(), op.axes.end(), 0);
Khalique's avatar
Khalique committed
357
    auto l1          = p.add_instruction(op, l0);
Paul's avatar
Paul committed
358
    auto shrink_axis = 1;
Khalique's avatar
Khalique committed
359
    p.add_instruction(migraphx::op::squeeze{{shrink_axis}}, l1);
Paul's avatar
Paul committed
360
    auto prog = optimize_tf("stridedslice_test.pb", true);
Khalique's avatar
Khalique committed
361
362
363
364

    EXPECT(p == prog);
}

365
int main(int argc, const char* argv[]) { test::run(argc, argv); }