tf_test.cpp 26.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"

14
15
16
17
18
migraphx::program parse_tf(const std::string& name, bool is_nhwc)
{
    return migraphx::parse_tf(name, migraphx::tf_options{is_nhwc, 1});
}

Paul's avatar
Paul committed
19
20
migraphx::program optimize_tf(const std::string& name, bool is_nhwc)
{
21
    auto prog = migraphx::parse_tf(name, migraphx::tf_options{is_nhwc, 1});
22
    auto* mm  = prog.get_main_module();
Paul's avatar
Paul committed
23
    if(is_nhwc)
24
        migraphx::run_passes(*mm,
Paul's avatar
Paul committed
25
26
27
                             {migraphx::simplify_reshapes{},
                              migraphx::dead_code_elimination{},
                              migraphx::eliminate_identity{}});
Paul's avatar
Paul committed
28
29
30
    return prog;
}

31
32
33
TEST_CASE(add_test)
{
    migraphx::program p;
34
35
36
37
38

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    mm->add_instruction(migraphx::op::add{}, l0, l1);
Paul's avatar
Paul committed
39
    auto prog = optimize_tf("add_test.pb", false);
40
41
42
43

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
44
45
46
47
48
49
50
51
52
53
54
TEST_CASE(addv2_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);
    auto prog = optimize_tf("addv2_test.pb", false);

    EXPECT(p == prog);
}

55
56
TEST_CASE(add_bcast_test)
{
Khalique's avatar
Khalique committed
57

58
    migraphx::program p;
59
60

    auto* mm = p.get_main_module();
61
    migraphx::shape s0{migraphx::shape::float_type, {2, 3}};
62
63
64
65
66
    auto l0 = mm->add_parameter("0", s0);
    auto l1 = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2, 1}});
    auto l2 = mm->add_instruction(migraphx::op::multibroadcast{s0.lens()}, l0);
    auto l3 = mm->add_instruction(migraphx::op::multibroadcast{s0.lens()}, l1);
    mm->add_instruction(migraphx::op::add{}, l2, l3);
Paul's avatar
Paul committed
67
    auto prog = optimize_tf("add_bcast_test.pb", false);
68
69
70
71

    EXPECT(p == prog);
}

72
73
74
TEST_CASE(argmax_test)
{
    migraphx::program p;
75
76
77
78
79
80

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int32_type}, {2}});
    auto ins = mm->add_instruction(migraphx::op::argmax{2}, l0);
    mm->add_instruction(migraphx::op::squeeze{{2}}, ins);
81
82
83
84
85
86
87
88
    auto prog = parse_tf("argmax_test.pb", false);

    EXPECT(p == prog);
}

TEST_CASE(argmin_test)
{
    migraphx::program p;
89
90
91
92
93
94

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int32_type}, {2}});
    auto ins = mm->add_instruction(migraphx::op::argmin{2}, l0);
    mm->add_instruction(migraphx::op::squeeze{{2}}, ins);
95
96
97
98
99
    auto prog = parse_tf("argmin_test.pb", false);

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
100
101
102
TEST_CASE(assert_less_equal_test)
{
    migraphx::program p;
103
104

    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
105
    migraphx::shape s0{migraphx::shape::float_type, {2, 3}};
106
107
    auto l0 = mm->add_parameter("0", s0);
    auto l1 = mm->add_parameter("1", s0);
Khalique's avatar
Khalique committed
108
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {0, 1}};
109
110
111
112
    auto l2 = mm->add_literal(l);
    mm->add_instruction(migraphx::op::add{}, l0, l1);
    auto l3 = mm->add_instruction(migraphx::op::identity{}, l0, l1);
    mm->add_instruction(migraphx::op::identity{}, l3, l2);
Khalique's avatar
Khalique committed
113
114
115
116
117
    auto prog = optimize_tf("assert_less_equal_test.pb", false);

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
118
119
120
121
TEST_CASE(batchmatmul_test)
{
    migraphx::program p;

122
123
124
125
126
127
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 8, 4}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 4, 8}});

    auto trans_l0 = mm->add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l0);
    auto trans_l1 = mm->add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l1);
Khalique's avatar
Khalique committed
128

129
    mm->add_instruction(migraphx::op::dot{}, trans_l0, trans_l1);
Khalique's avatar
Khalique committed
130
131
132
133
134
    auto prog = optimize_tf("batchmatmul_test.pb", false);

    EXPECT(p == prog);
}

135
136
TEST_CASE(batchnorm_test)
{
Khalique's avatar
Khalique committed
137
138
    float epsilon  = 1.001e-5f;
    float momentum = 0.9f;
139
140

    migraphx::program p;
141
142

    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
143
144
    migraphx::op::batch_norm_inference op{
        epsilon, momentum, migraphx::op::batch_norm_inference::spatial};
145
    migraphx::shape s0{migraphx::shape::float_type, {32}};
146
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 32, 16, 16}});
147
148
    std::vector<float> const_vals(32);
    std::fill(const_vals.begin(), const_vals.end(), 1.0f);
Khalique's avatar
Khalique committed
149

150
151
152
153
154
    auto l2 = mm->add_parameter("2", s0);
    auto l3 = mm->add_parameter("3", s0);
    auto l4 = mm->add_parameter("4", s0);
    auto l1 = mm->add_literal(migraphx::literal{s0, const_vals});
    mm->add_instruction(op, l0, l1, l2, l3, l4);
Paul's avatar
Paul committed
155
    auto prog = optimize_tf("batchnorm_test.pb", true);
156
157
158
159

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
TEST_CASE(batchnormv3_test)
{
    float epsilon  = 1.0e-5f;
    float momentum = 0.9f;

    migraphx::program p;
    migraphx::op::batch_norm_inference op{
        epsilon, momentum, migraphx::op::batch_norm_inference::spatial};
    migraphx::shape s0{migraphx::shape::float_type, {32}};
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 32, 16, 16}});
    std::vector<float> const_vals(32);
    std::fill(const_vals.begin(), const_vals.end(), 1.0f);

    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);
    auto prog = optimize_tf("batchnormv3_test.pb", true);

    EXPECT(p == prog);
}

183
184
185
TEST_CASE(biasadd_test)
{
    migraphx::program p;
186
187

    auto* mm = p.get_main_module();
188
    migraphx::shape s0{migraphx::shape::float_type, {1, 500, 1, 1}};
189
    uint64_t axis = 1;
190
191
192
193
    auto l0       = mm->add_parameter("0", s0);
    auto l1       = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {500}});
    auto l2       = mm->add_instruction(migraphx::op::broadcast{axis, l0->get_shape().lens()}, l1);
    mm->add_instruction(migraphx::op::add{}, l0, l2);
Paul's avatar
Paul committed
194
    auto prog = optimize_tf("biasadd_test.pb", true);
195
196
197
198

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
199
200
201
TEST_CASE(cast_test)
{
    migraphx::program p;
202
203
204
205

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    mm->add_instruction(migraphx::op::convert{migraphx::shape::int32_type}, l0);
Khalique's avatar
Khalique committed
206
207
208
209
210
    auto prog = optimize_tf("cast_test.pb", false);

    EXPECT(p == prog);
}

211
212
213
TEST_CASE(concat_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
214

215
216
217
218
    auto* mm = p.get_main_module();

    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {4, 7, 3}});
    auto l1 = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 2, 3}});
219
220
221

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

225
    mm->add_instruction(migraphx::op::concat{axis}, l0, l1);
Paul's avatar
Paul committed
226
    auto prog = optimize_tf("concat_test.pb", false);
227
228
229
230
231
232
233

    EXPECT(p == prog);
}

TEST_CASE(const_test)
{
    migraphx::program p;
234
235
236

    auto* mm = p.get_main_module();
    mm->add_literal(migraphx::shape{migraphx::shape::float_type}, std::vector<float>{1.0f});
Paul's avatar
Paul committed
237
    auto prog = optimize_tf("constant_test.pb", false);
238
239
240
241
242
243
244

    EXPECT(p == prog);
}

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

246
247
248
    auto* mm = p.get_main_module();

    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
Khalique's avatar
Khalique committed
249
    std::vector<float> weight_data(3 * 3 * 3 * 32);
250
    std::fill(weight_data.begin(), weight_data.end(), 1.0f);
Khalique's avatar
Khalique committed
251
    auto l1 =
252
        mm->add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 32}}, weight_data);
253
254
255

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
Khalique's avatar
Khalique committed
256
    op.padding      = {1, 1};
Khalique's avatar
Khalique committed
257
258
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
259
260
    auto l2         = mm->add_instruction(migraphx::op::transpose{{3, 2, 0, 1}}, l1);
    mm->add_instruction(op, l0, l2);
Paul's avatar
Paul committed
261
    auto prog = optimize_tf("conv_test.pb", true);
262
263
264
265

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
266
267
268
269
TEST_CASE(depthwiseconv_test)
{
    migraphx::program p;

270
271
272
    auto* mm = p.get_main_module();

    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
Khalique's avatar
Khalique committed
273
274
275
    std::vector<float> weight_data(3 * 3 * 3 * 1);
    std::fill(weight_data.begin(), weight_data.end(), 1.0f);
    auto l1 =
276
        mm->add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 1}}, weight_data);
Khalique's avatar
Khalique committed
277
278
279

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
Khalique's avatar
Khalique committed
280
    op.padding      = {1, 1};
Khalique's avatar
Khalique committed
281
282
283
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
    op.group        = 3;
284
285
286
287
    auto l3         = mm->add_instruction(migraphx::op::transpose{{3, 2, 0, 1}}, l1);
    auto l4         = mm->add_instruction(migraphx::op::contiguous{}, l3);
    auto l5         = mm->add_instruction(migraphx::op::reshape{{3, 1, 3, 3}}, l4);
    mm->add_instruction(op, l0, l5);
Paul's avatar
Paul committed
288
    auto prog = optimize_tf("depthwise_conv_test.pb", true);
Khalique's avatar
Khalique committed
289
290
291
292

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
293
294
295
TEST_CASE(expanddims_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
296

297
298
299
300
301
    auto* mm = p.get_main_module();

    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4}});
    mm->add_literal(0);
    mm->add_instruction(migraphx::op::reshape{{1, 2, 3, 4}}, l0);
302
    auto prog = optimize_tf("expanddims_test.pb", false);
Khalique's avatar
Khalique committed
303
304
305
306
307
308
309
310
311

    EXPECT(p == prog);
}

TEST_CASE(expanddims_test_neg_dims)
{
    // this check makes sure the pb parses negative dim value correctly
    migraphx::program p;

312
313
314
315
316
    auto* mm = p.get_main_module();

    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4}});
    mm->add_literal(-1);
    mm->add_instruction(migraphx::op::reshape{{2, 3, 4, 1}}, l0);
317
    auto prog = optimize_tf("expanddims_neg_test.pb", false);
Khalique's avatar
Khalique committed
318
319
320
321

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
322
323
324
325
TEST_CASE(gather_test)
{
    migraphx::program p;

326
327
328
329
330
331
    auto* mm = p.get_main_module();

    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 4}});
    auto l1 = mm->add_literal(
        migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {2}}, {1, 1}});
    mm->add_literal(1);
Khalique's avatar
Khalique committed
332
333

    int axis = 1;
334
    mm->add_instruction(migraphx::op::gather{axis}, l0, l1);
Khalique's avatar
Khalique committed
335
336
    auto prog = optimize_tf("gather_test.pb", false);

Khalique's avatar
Khalique committed
337
338
339
    EXPECT(p == prog);
}

340
341
342
TEST_CASE(identity_test)
{
    migraphx::program p;
343
344
345
346

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    mm->add_instruction(migraphx::op::identity{}, l0);
Paul's avatar
Paul committed
347
    auto prog = optimize_tf("identity_test.pb", false);
348
349
350
351

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
352
353
354
TEST_CASE(matmul_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
355

356
357
358
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {8, 4}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 8}});
Khalique's avatar
Khalique committed
359

360
361
362
363
    auto trans_l0 = mm->add_instruction(migraphx::op::transpose{{1, 0}}, l0);
    auto trans_l1 = mm->add_instruction(migraphx::op::transpose{{1, 0}}, l1);

    mm->add_instruction(migraphx::op::dot{}, trans_l0, trans_l1);
Paul's avatar
Paul committed
364
    auto prog = optimize_tf("matmul_test.pb", false);
Khalique's avatar
Khalique committed
365
366
367
368

    EXPECT(p == prog);
}

369
370
371
TEST_CASE(mean_test)
{
    migraphx::program p;
372
373

    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
374
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {2, 3}};
375
376
377
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    mm->add_literal(l);
    mm->add_literal(l);
Paul's avatar
Paul committed
378
    migraphx::op::reduce_mean op{{2, 3}};
379
380
381
    mm->add_instruction(op, l0);
    auto l3 = mm->add_instruction(op, l0);
    mm->add_instruction(migraphx::op::squeeze{{2, 3}}, l3);
Paul's avatar
Paul committed
382
    auto prog = optimize_tf("mean_test.pb", false);
383
384
385
386
387
388
389

    EXPECT(p == prog);
}

TEST_CASE(mean_test_nhwc)
{
    migraphx::program p;
390
391

    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
392
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {1, 2}};
393
394
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    auto l1 = mm->add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l0);
Khalique's avatar
Khalique committed
395
    migraphx::op::reduce_mean op{{1, 2}};
396
397
    auto l2 = mm->add_instruction(op, l1);
    mm->add_instruction(migraphx::op::squeeze{{1, 2}}, l2);
Paul's avatar
Paul committed
398
    auto prog = optimize_tf("mean_test_nhwc.pb", true);
399
400
401
402

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
403
404
405
406
TEST_CASE(mul_test)
{
    migraphx::program p;

407
408
409
410
411
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 1, 1, 16}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 1, 16}});

    mm->add_instruction(migraphx::op::mul{}, l0, l1);
Paul's avatar
Paul committed
412
    auto prog = optimize_tf("mul_test.pb", false);
Khalique's avatar
Khalique committed
413
414
415
416

    EXPECT(p == prog);
}

417
418
419
TEST_CASE(onehot_test)
{
    migraphx::program p;
420
421
422

    auto* mm = p.get_main_module();
    auto l0  = mm->add_literal(
Khalique's avatar
Khalique committed
423
        migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {5}}, {1, 1, 1, 1, 1}});
424
425
426
427
    mm->add_literal(2);
    mm->add_literal(1.0f);
    mm->add_literal(0.0f);
    auto l1 = mm->add_literal(
Khalique's avatar
Khalique committed
428
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {2, 2}}, {1, 0, 0, 1}});
429
    int axis = 0;
430
    mm->add_instruction(migraphx::op::gather{axis}, l1, l0);
431
432
433
434
435
    auto prog = optimize_tf("onehot_test.pb", false);

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
436
437
438
439
440
441
442
443
TEST_CASE(noop_test)
{
    migraphx::program p;
    auto prog = optimize_tf("noop_test.pb", false);

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
444
445
446
TEST_CASE(pack_test)
{
    migraphx::program p;
447
448
449
450
451

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2}});
    auto l2  = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {2}});
Khalique's avatar
Khalique committed
452
453
454
455
    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
456
457
458
459
    std::transform(args.begin(),
                   args.end(),
                   std::back_inserter(unsqueezed_args),
                   [&](migraphx::instruction_ref arg) {
460
                       return mm->add_instruction(migraphx::op::unsqueeze{{axis}}, arg);
Khalique's avatar
Khalique committed
461
                   });
462
    mm->add_instruction(migraphx::op::concat{static_cast<int>(axis)}, unsqueezed_args);
Paul's avatar
Paul committed
463
    auto prog = optimize_tf("pack_test.pb", false);
Khalique's avatar
Khalique committed
464
465
466
467

    EXPECT(p == prog);
}

468
469
470
TEST_CASE(pack_test_nhwc)
{
    migraphx::program p;
471
472
473
474
475
476
477
478

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
    auto lt0 = mm->add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l0);
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
    auto lt1 = mm->add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l1);
    auto l2  = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
    auto lt2 = mm->add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l2);
Paul's avatar
Paul committed
479
    std::vector<migraphx::instruction_ref> args{lt0, lt1, lt2};
480
    std::vector<migraphx::instruction_ref> unsqueezed_args;
Paul's avatar
Paul committed
481
    int64_t nchw_axis = 3;
482
483
484
485
486

    std::transform(args.begin(),
                   args.end(),
                   std::back_inserter(unsqueezed_args),
                   [&](migraphx::instruction_ref arg) {
487
                       return mm->add_instruction(migraphx::op::unsqueeze{{nchw_axis}}, arg);
488
                   });
489
    mm->add_instruction(migraphx::op::concat{static_cast<int>(nchw_axis)}, unsqueezed_args);
Paul's avatar
Paul committed
490
    auto prog = optimize_tf("pack_test_nhwc.pb", true);
491
492
493
494

    EXPECT(p == prog);
}

495
496
497
TEST_CASE(pooling_test)
{
    migraphx::program p;
498
499
500

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
501
502
    migraphx::op::pooling avg_pool_op{"average"};
    migraphx::op::pooling max_pool_op{"max"};
Shucai Xiao's avatar
Shucai Xiao committed
503
504
505
506
    avg_pool_op.stride  = {2, 2};
    max_pool_op.stride  = {2, 2};
    avg_pool_op.lengths = {2, 2};
    max_pool_op.lengths = {2, 2};
507
    mm->add_instruction(max_pool_op, l0);
Paul's avatar
Paul committed
508
    auto prog = optimize_tf("pooling_test.pb", true);
509
510
511
512

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
513
514
515
TEST_CASE(pow_test)
{
    migraphx::program p;
516
517
518
519
520

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    mm->add_instruction(migraphx::op::pow{}, l0, l1);
Khalique's avatar
Khalique committed
521
522
523
524
525
    auto prog = optimize_tf("pow_test.pb", false);

    EXPECT(p == prog);
}

526
527
528
TEST_CASE(relu_test)
{
    migraphx::program p;
529
530
531
532

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    mm->add_instruction(migraphx::op::relu{}, l0);
Paul's avatar
Paul committed
533
    auto prog = optimize_tf("relu_test.pb", false);
534
535
536
537

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
538
539
540
TEST_CASE(relu6_test)
{
    migraphx::program p;
541
542

    auto* mm = p.get_main_module();
kahmed10's avatar
kahmed10 committed
543
    std::vector<size_t> input_lens{1, 3, 16, 16};
544
545
546
547
548
549
    auto l0      = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, input_lens});
    auto min_val = mm->add_literal(0.0f);
    auto max_val = mm->add_literal(6.0f);
    min_val      = mm->add_instruction(migraphx::op::multibroadcast{input_lens}, min_val);
    max_val      = mm->add_instruction(migraphx::op::multibroadcast{input_lens}, max_val);
    mm->add_instruction(migraphx::op::clip{}, l0, min_val, max_val);
Paul's avatar
Paul committed
550
    auto prog = optimize_tf("relu6_test.pb", false);
Khalique's avatar
Khalique committed
551
552
553
554

    EXPECT(p == prog);
}

555
556
557
TEST_CASE(reshape_test)
{
    migraphx::program p;
558
559
560

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {16}});
561
562
    migraphx::shape s0{migraphx::shape::int32_type, {4}};
    // in tf, the second arg is a literal that contains new dimensions
563
564
    mm->add_literal(migraphx::literal{s0, {1, 1, 1, 16}});
    mm->add_instruction(migraphx::op::reshape{{1, 1, 1, 16}}, l0);
Paul's avatar
Paul committed
565
    auto prog = optimize_tf("reshape_test.pb", false);
566
567
568
569

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
570
571
572
TEST_CASE(rsqrt_test)
{
    migraphx::program p;
573
574
575
576

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    mm->add_instruction(migraphx::op::rsqrt{}, l0);
Khalique's avatar
Khalique committed
577
578
579
580
581
    auto prog = optimize_tf("rsqrt_test.pb", false);

    EXPECT(p == prog);
}

582
583
584
TEST_CASE(shape_test)
{
    migraphx::program p;
585
586
587
588

    auto* mm = p.get_main_module();
    mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    mm->add_literal(
589
590
591
592
593
594
        migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {4}}, {1, 3, 16, 16}});
    auto prog = optimize_tf("shape_test.pb", false);

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
595
596
597
TEST_CASE(slice_test)
{
    migraphx::program p;
598
599

    auto* mm             = p.get_main_module();
Khalique's avatar
Khalique committed
600
    std::size_t num_axes = 2;
601
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 10}});
Khalique's avatar
Khalique committed
602
    migraphx::shape s0{migraphx::shape::int32_type, {num_axes}};
603
604
    mm->add_literal(migraphx::literal{s0, {1, 0}});
    mm->add_literal(migraphx::literal{s0, {2, -1}});
Khalique's avatar
Khalique committed
605
606
607
608
609
610

    migraphx::op::slice op;
    op.starts = {1, 0};
    op.ends   = {3, 10};
    op.axes   = std::vector<int64_t>(num_axes);
    std::iota(op.axes.begin(), op.axes.end(), 0);
611
    mm->add_instruction(op, l0);
Khalique's avatar
Khalique committed
612
613
614
615
616
    auto prog = optimize_tf("slice_test.pb", false);

    EXPECT(p == prog);
}

617
618
619
TEST_CASE(softmax_test)
{
    migraphx::program p;
620
621
622
623

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
    mm->add_instruction(migraphx::op::softmax{1}, l0);
Paul's avatar
Paul committed
624
    auto prog = optimize_tf("softmax_test.pb", false);
625
626
627
628

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
629
630
631
TEST_CASE(split_test)
{
    migraphx::program p;
632
633

    auto* mm = p.get_main_module();
kahmed10's avatar
kahmed10 committed
634
    std::vector<int64_t> axes{0, 1};
635
636
637
638
639
640
641
642
643
644
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 30}});
    mm->add_literal(3); // num_splits
    mm->add_literal(1); // split axis
    mm->add_literal(1); // concat axis
    mm->add_literal(1); // concat axis
    auto l1 = mm->add_instruction(migraphx::op::slice{axes, {0, 0}, {5, 10}}, l0);
    auto l2 = mm->add_instruction(migraphx::op::slice{axes, {0, 10}, {5, 20}}, l0);
    auto l3 = mm->add_instruction(migraphx::op::slice{axes, {0, 20}, {5, 30}}, l0);
    mm->add_instruction(migraphx::op::concat{1}, l1, l2);
    mm->add_instruction(migraphx::op::concat{1}, l2, l3);
kahmed10's avatar
kahmed10 committed
645

646
    auto prog = parse_tf("split_test.pb", false);
kahmed10's avatar
kahmed10 committed
647
648
649
650
651
652
653

    EXPECT(p == prog);
}

TEST_CASE(split_test_one_output)
{
    migraphx::program p;
654
655
656
657
658
659

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 30}});
    mm->add_literal(1); // num_splits
    mm->add_literal(1); // split axis
    mm->add_instruction(migraphx::op::identity{}, l0);
kahmed10's avatar
kahmed10 committed
660

661
    auto prog = parse_tf("split_test_one_output.pb", false);
kahmed10's avatar
kahmed10 committed
662
663
664
665
666
667
668

    EXPECT(p == prog);
}

TEST_CASE(split_test_vector_as_input)
{
    migraphx::program p;
669
670

    auto* mm = p.get_main_module();
kahmed10's avatar
kahmed10 committed
671
    std::vector<int64_t> axes{0, 1};
672
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 30}});
kahmed10's avatar
kahmed10 committed
673
    // split sizes
674
    mm->add_literal(
kahmed10's avatar
kahmed10 committed
675
        migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {3}}, {4, 15, 11}});
676
677
678
679
680
681
682
683
    mm->add_literal(1); // split axis
    mm->add_literal(1); // concat axis
    mm->add_literal(1); // concat axis
    auto l1 = mm->add_instruction(migraphx::op::slice{axes, {0, 0}, {5, 4}}, l0);
    auto l2 = mm->add_instruction(migraphx::op::slice{axes, {0, 4}, {5, 19}}, l0);
    auto l3 = mm->add_instruction(migraphx::op::slice{axes, {0, 19}, {5, 30}}, l0);
    mm->add_instruction(migraphx::op::concat{1}, l1, l2);
    mm->add_instruction(migraphx::op::concat{1}, l2, l3);
kahmed10's avatar
kahmed10 committed
684

685
    auto prog = parse_tf("split_test_vector_as_input.pb", false);
kahmed10's avatar
kahmed10 committed
686
687
688
689

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
690
691
692
TEST_CASE(sqdiff_test)
{
    migraphx::program p;
693
694
695
696
697

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    mm->add_instruction(migraphx::op::sqdiff{}, l0, l1);
Khalique's avatar
Khalique committed
698
699
700
701
702
    auto prog = optimize_tf("sqdiff_test.pb", false);

    EXPECT(p == prog);
}

703
704
705
TEST_CASE(squeeze_test)
{
    migraphx::program p;
706
707
708
709

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 3, 1}});
    mm->add_instruction(migraphx::op::squeeze{{0, 3}}, l0);
Paul's avatar
Paul committed
710
    auto prog = optimize_tf("squeeze_test.pb", false);
711
712
713

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

Khalique's avatar
Khalique committed
715
716
717
TEST_CASE(stopgradient_test)
{
    migraphx::program p;
718
719
720
721

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    mm->add_instruction(migraphx::op::identity{}, l0);
Khalique's avatar
Khalique committed
722
723
    auto prog = optimize_tf("stopgradient_test.pb", false);

Khalique's avatar
Khalique committed
724
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
725
726
}

Khalique's avatar
Khalique committed
727
728
729
TEST_CASE(stridedslice_test)
{
    migraphx::program p;
730
731
732
733

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 10, 1, 1}});
    auto l1  = mm->add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l0);
Khalique's avatar
Khalique committed
734
735
    std::size_t num_axes = 4;
    migraphx::op::slice op;
Khalique's avatar
Khalique committed
736
    op.starts = {0, 0, 0, 0};
Paul's avatar
Paul committed
737
    op.ends   = {1, 1, 1, 5};
Khalique's avatar
Khalique committed
738
739
    op.axes   = std::vector<int64_t>(num_axes);
    std::iota(op.axes.begin(), op.axes.end(), 0);
740
    auto l2          = mm->add_instruction(op, l1);
Paul's avatar
Paul committed
741
    auto shrink_axis = 1;
742
    mm->add_instruction(migraphx::op::squeeze{{shrink_axis}}, l2);
Paul's avatar
Paul committed
743
    auto prog = optimize_tf("stridedslice_test.pb", true);
Khalique's avatar
Khalique committed
744
745
746
747

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
748
749
750
TEST_CASE(stridedslice_masks_test)
{
    migraphx::program p;
751
752
753

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 10, 3, 3}});
Khalique's avatar
Khalique committed
754
755
    std::size_t num_axes = 4;
    migraphx::op::slice op;
756
757
    op.starts = {0, 1, 1, 0};
    op.ends   = {1, 3, 3, 10};
Khalique's avatar
Khalique committed
758
759
760
    op.axes   = std::vector<int64_t>(num_axes);
    std::iota(op.axes.begin(), op.axes.end(), 0);
    // add literals for starts, ends, and strides in tf (NHWC format)
761
762
763
764
765
766
767
768
769
770
    mm->add_literal(migraphx::shape{migraphx::shape::int32_type, {4}},
                    std::vector<int>{0, 1, 1, 0});
    mm->add_literal(migraphx::shape{migraphx::shape::int32_type, {4}},
                    std::vector<int>{0, 0, 0, 0});
    mm->add_literal(migraphx::shape{migraphx::shape::int32_type, {4}},
                    std::vector<int>{1, 1, 1, 1});

    auto l1 = mm->add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l0);
    auto l2 = mm->add_instruction(op, l1);
    mm->add_instruction(migraphx::op::transpose{{0, 3, 1, 2}}, l2);
771
    auto prog = parse_tf("stridedslice_masks_test.pb", true);
Khalique's avatar
Khalique committed
772
773
774
775

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
776
777
778
TEST_CASE(sub_test)
{
    migraphx::program p;
779
780
781
782
783

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    mm->add_instruction(migraphx::op::sub{}, l0, l1);
784
    auto prog = parse_tf("sub_test.pb", false);
Khalique's avatar
Khalique committed
785
786
787
788

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
789
790
791
TEST_CASE(tanh_test)
{
    migraphx::program p;
792
793
794
795
796

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    mm->add_instruction(migraphx::op::sub{}, l0, l1);
797
    auto prog = parse_tf("sub_test.pb", false);
Khalique's avatar
Khalique committed
798
799
800
801

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
802
803
804
TEST_CASE(transpose_test)
{
    migraphx::program p;
805
806
807

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
Khalique's avatar
Khalique committed
808
    migraphx::shape s0{migraphx::shape::int32_type, {4}};
809
810
    mm->add_literal(migraphx::literal{s0, {0, 2, 3, 1}});
    mm->add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l0);
Khalique's avatar
Khalique committed
811
812
813
814
815
    auto prog = optimize_tf("transpose_test.pb", false);

    EXPECT(p == prog);
}

816
817
818
TEST_CASE(variable_batch_test)
{
    migraphx::program p;
819
820
821
822

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    mm->add_instruction(migraphx::op::identity{}, l0);
823
824
825
826
827
    auto prog = optimize_tf("variable_batch_test.pb", false);

    EXPECT(p == prog);
}

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