tf_test.cpp 13.8 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
migraphx::program optimize_tf(const std::string& name, bool is_nhwc)
{
    auto prog = migraphx::parse_tf(name, is_nhwc);
Paul's avatar
Paul committed
17
18
19
20
21
    if(is_nhwc)
        migraphx::run_passes(prog,
                             {migraphx::simplify_reshapes{},
                              migraphx::dead_code_elimination{},
                              migraphx::eliminate_identity{}});
Paul's avatar
Paul committed
22
23
24
    return prog;
}

25
26
27
28
29
30
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
31
    auto prog = optimize_tf("add_test.pb", false);
32
33
34
35
36
37

    EXPECT(p == prog);
}

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

39
40
41
42
43
44
45
    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
46
    auto prog = optimize_tf("add_bcast_test.pb", false);
47
48
49
50

    EXPECT(p == prog);
}

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

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

64
65
66
67
68
    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
69
    auto prog = optimize_tf("batchnorm_test.pb", true);
70
71
72
73

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

88
89
90
TEST_CASE(concat_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
91

92
93
94
95
96
    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
97
    // add the literal using a vector in order to set stride to 1 (like in tf parser)
98
    p.add_literal(migraphx::shape{migraphx::shape::int32_type}, std::vector<int>{axis});
99
100

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

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

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

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

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
Khalique's avatar
Khalique committed
127
    op.padding      = {1, 1};
Khalique's avatar
Khalique committed
128
129
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
Paul's avatar
Paul committed
130
131
132
    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);
133
134
135
136

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
137
138
139
140
141
142
143
144
145
146
147
148
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;
Khalique's avatar
Khalique committed
149
    op.padding      = {1, 1};
Khalique's avatar
Khalique committed
150
151
152
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
    op.group        = 3;
Paul's avatar
Paul committed
153
    auto l3         = p.add_instruction(migraphx::op::transpose{{3, 2, 0, 1}}, l1);
Paul's avatar
Paul committed
154
155
156
    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
157
    auto prog = optimize_tf("depthwise_conv_test.pb", true);
Khalique's avatar
Khalique committed
158
159
160
161

    EXPECT(p == prog);
}

162
163
164
165
166
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
167
    auto prog = optimize_tf("identity_test.pb", false);
168
169
170
171

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
172
173
174
175
176
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
177
178
179

    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
180
181

    p.add_instruction(migraphx::op::dot{}, trans_l0, trans_l1);
Paul's avatar
Paul committed
182
    auto prog = optimize_tf("matmul_test.pb", false);
Khalique's avatar
Khalique committed
183
184
185
186

    EXPECT(p == prog);
}

187
188
189
TEST_CASE(mean_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
190
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {2, 3}};
191
192
193
194
    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
195
    op.lengths = {16, 16};
Paul's avatar
Paul committed
196
    p.add_instruction(op, l0);
Paul's avatar
Paul committed
197
    auto l3 = p.add_instruction(op, l0);
Khalique's avatar
Khalique committed
198
    p.add_instruction(migraphx::op::squeeze{{2, 3}}, l3);
Paul's avatar
Paul committed
199
    auto prog = optimize_tf("mean_test.pb", false);
200
201
202
203
204
205
206

    EXPECT(p == prog);
}

TEST_CASE(mean_test_nhwc)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
207
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {1, 2}};
208
209
    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
210
211
212
    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
213
    auto prog = optimize_tf("mean_test_nhwc.pb", true);
214
215
216
217

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
218
219
220
TEST_CASE(mul_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
221
222
    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
223
224

    p.add_instruction(migraphx::op::mul{}, l0, l1);
Paul's avatar
Paul committed
225
    auto prog = optimize_tf("mul_test.pb", false);
Khalique's avatar
Khalique committed
226
227
228
229

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
230
231
232
233
234
235
236
237
238
239
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
240
241
242
243
244
245
    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
246
    p.add_instruction(migraphx::op::concat{static_cast<size_t>(axis)}, unsqueezed_args);
Paul's avatar
Paul committed
247
    auto prog = optimize_tf("pack_test.pb", false);
Khalique's avatar
Khalique committed
248
249
250
251

    EXPECT(p == prog);
}

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

    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
272
    auto prog = optimize_tf("pack_test_nhwc.pb", true);
273
274
275
276

    EXPECT(p == prog);
}

277
278
279
TEST_CASE(pooling_test)
{
    migraphx::program p;
280
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
281
282
283
284
    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
285
286
287
288
    avg_pool_op.stride       = {2, 2};
    max_pool_op.stride       = {2, 2};
    avg_pool_op.lengths      = {2, 2};
    max_pool_op.lengths      = {2, 2};
289
    p.add_instruction(max_pool_op, l0);
Paul's avatar
Paul committed
290
291
    // p.add_instruction(avg_pool_op, l0);
    auto prog = optimize_tf("pooling_test.pb", true);
292
293
294
295

    EXPECT(p == prog);
}

296
297
298
299
300
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
301
    auto prog = optimize_tf("relu_test.pb", false);
302
303
304
305

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
306
307
308
309
310
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
311
    auto prog = optimize_tf("relu6_test.pb", false);
Khalique's avatar
Khalique committed
312
313
314
315

    EXPECT(p == prog);
}

316
317
318
319
320
321
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
322
323
    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
324
    auto prog = optimize_tf("reshape_test.pb", false);
325
326
327
328
329
330
331

    EXPECT(p == prog);
}

TEST_CASE(softmax_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
332
    auto l0   = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
333
    auto dims = l0->get_shape().lens();
Khalique's avatar
Khalique committed
334
335
    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);
336
    p.add_instruction(migraphx::op::reshape{{long(dims[0]), long(dims[1])}}, s);
Paul's avatar
Paul committed
337
    auto prog = optimize_tf("softmax_test.pb", false);
338
339
340
341
342
343
344

    EXPECT(p == prog);
}

TEST_CASE(squeeze_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
345
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 3, 1}});
346
    p.add_instruction(migraphx::op::squeeze{{0, 3}}, l0);
Paul's avatar
Paul committed
347
    auto prog = optimize_tf("squeeze_test.pb", false);
348
349
350

    EXPECT(p == prog);
}
Khalique's avatar
Khalique committed
351

Khalique's avatar
Khalique committed
352
353
354
355
356
357
358
TEST_CASE(stopgradient_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);
    auto prog = optimize_tf("stopgradient_test.pb", false);

Khalique's avatar
Khalique committed
359
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
360
361
}

Khalique's avatar
Khalique committed
362
363
364
365
366
367
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
368
    op.starts = {0, 0, 0, 0};
Paul's avatar
Paul committed
369
    op.ends   = {1, 1, 1, 5};
Khalique's avatar
Khalique committed
370
371
    op.axes   = std::vector<int64_t>(num_axes);
    std::iota(op.axes.begin(), op.axes.end(), 0);
Khalique's avatar
Khalique committed
372
    auto l1          = p.add_instruction(op, l0);
Paul's avatar
Paul committed
373
    auto shrink_axis = 1;
Khalique's avatar
Khalique committed
374
    p.add_instruction(migraphx::op::squeeze{{shrink_axis}}, l1);
Paul's avatar
Paul committed
375
    auto prog = optimize_tf("stridedslice_test.pb", true);
Khalique's avatar
Khalique committed
376
377
378
379

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
380
381
382
383
384
385
386
387
388
389
390
TEST_CASE(sub_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::sub{}, l0, l1);
    auto prog = migraphx::parse_tf("sub_test.pb", false);

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
391
392
393
TEST_CASE(tanh_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
394
395
396
397
    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::sub{}, l0, l1);
    auto prog = migraphx::parse_tf("sub_test.pb", false);
Khalique's avatar
Khalique committed
398
399
400
401

    EXPECT(p == prog);
}

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