tf_test.cpp 25.5 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
44
45

    EXPECT(p == prog);
}

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

47
    migraphx::program p;
48
49

    auto* mm = p.get_main_module();
50
    migraphx::shape s0{migraphx::shape::float_type, {2, 3}};
51
52
53
54
55
    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
56
    auto prog = optimize_tf("add_bcast_test.pb", false);
57
58
59
60

    EXPECT(p == prog);
}

61
62
63
TEST_CASE(argmax_test)
{
    migraphx::program p;
64
65
66
67
68
69

    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);
70
71
72
73
74
75
76
77
    auto prog = parse_tf("argmax_test.pb", false);

    EXPECT(p == prog);
}

TEST_CASE(argmin_test)
{
    migraphx::program p;
78
79
80
81
82
83

    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);
84
85
86
87
88
    auto prog = parse_tf("argmin_test.pb", false);

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
89
90
91
TEST_CASE(assert_less_equal_test)
{
    migraphx::program p;
92
93

    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
94
    migraphx::shape s0{migraphx::shape::float_type, {2, 3}};
95
96
    auto l0 = mm->add_parameter("0", s0);
    auto l1 = mm->add_parameter("1", s0);
Khalique's avatar
Khalique committed
97
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {0, 1}};
98
99
100
101
    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
102
103
104
105
106
    auto prog = optimize_tf("assert_less_equal_test.pb", false);

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
107
108
109
110
TEST_CASE(batchmatmul_test)
{
    migraphx::program p;

111
112
113
114
115
116
    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
117

118
    mm->add_instruction(migraphx::op::dot{}, trans_l0, trans_l1);
Khalique's avatar
Khalique committed
119
120
121
122
123
    auto prog = optimize_tf("batchmatmul_test.pb", false);

    EXPECT(p == prog);
}

124
125
TEST_CASE(batchnorm_test)
{
Khalique's avatar
Khalique committed
126
127
    float epsilon  = 1.001e-5f;
    float momentum = 0.9f;
128
129

    migraphx::program p;
130
131

    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
132
133
    migraphx::op::batch_norm_inference op{
        epsilon, momentum, migraphx::op::batch_norm_inference::spatial};
134
    migraphx::shape s0{migraphx::shape::float_type, {32}};
135
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 32, 16, 16}});
136
137
    std::vector<float> const_vals(32);
    std::fill(const_vals.begin(), const_vals.end(), 1.0f);
Khalique's avatar
Khalique committed
138

139
140
141
142
143
    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
144
    auto prog = optimize_tf("batchnorm_test.pb", true);
145
146
147
148

    EXPECT(p == prog);
}

149
150
151
TEST_CASE(biasadd_test)
{
    migraphx::program p;
152
153

    auto* mm = p.get_main_module();
154
    migraphx::shape s0{migraphx::shape::float_type, {1, 500, 1, 1}};
155
    uint64_t axis = 1;
156
157
158
159
    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
160
    auto prog = optimize_tf("biasadd_test.pb", true);
161
162
163
164

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
165
166
167
TEST_CASE(cast_test)
{
    migraphx::program p;
168
169
170
171

    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
172
173
174
175
176
    auto prog = optimize_tf("cast_test.pb", false);

    EXPECT(p == prog);
}

177
178
179
TEST_CASE(concat_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
180

181
182
183
184
    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}});
185
186
187

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

191
    mm->add_instruction(migraphx::op::concat{axis}, l0, l1);
Paul's avatar
Paul committed
192
    auto prog = optimize_tf("concat_test.pb", false);
193
194
195
196
197
198
199

    EXPECT(p == prog);
}

TEST_CASE(const_test)
{
    migraphx::program p;
200
201
202

    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
203
    auto prog = optimize_tf("constant_test.pb", false);
204
205
206
207
208
209
210

    EXPECT(p == prog);
}

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

212
213
214
    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
215
    std::vector<float> weight_data(3 * 3 * 3 * 32);
216
    std::fill(weight_data.begin(), weight_data.end(), 1.0f);
Khalique's avatar
Khalique committed
217
    auto l1 =
218
        mm->add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 32}}, weight_data);
219
220
221

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
Khalique's avatar
Khalique committed
222
    op.padding      = {1, 1};
Khalique's avatar
Khalique committed
223
224
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
225
226
    auto l2         = mm->add_instruction(migraphx::op::transpose{{3, 2, 0, 1}}, l1);
    mm->add_instruction(op, l0, l2);
Paul's avatar
Paul committed
227
    auto prog = optimize_tf("conv_test.pb", true);
228
229
230
231

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
232
233
234
235
TEST_CASE(depthwiseconv_test)
{
    migraphx::program p;

236
237
238
    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
239
240
241
    std::vector<float> weight_data(3 * 3 * 3 * 1);
    std::fill(weight_data.begin(), weight_data.end(), 1.0f);
    auto l1 =
242
        mm->add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 1}}, weight_data);
Khalique's avatar
Khalique committed
243
244
245

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
Khalique's avatar
Khalique committed
246
    op.padding      = {1, 1};
Khalique's avatar
Khalique committed
247
248
249
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
    op.group        = 3;
250
251
252
253
    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
254
    auto prog = optimize_tf("depthwise_conv_test.pb", true);
Khalique's avatar
Khalique committed
255
256
257
258

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
259
260
261
TEST_CASE(expanddims_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
262

263
264
265
266
267
    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);
268
    auto prog = optimize_tf("expanddims_test.pb", false);
Khalique's avatar
Khalique committed
269
270
271
272
273
274
275
276
277

    EXPECT(p == prog);
}

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

278
279
280
281
282
    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);
283
    auto prog = optimize_tf("expanddims_neg_test.pb", false);
Khalique's avatar
Khalique committed
284
285
286
287

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
288
289
290
291
TEST_CASE(gather_test)
{
    migraphx::program p;

292
293
294
295
296
297
    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
298
299

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

Khalique's avatar
Khalique committed
303
304
305
    EXPECT(p == prog);
}

306
307
308
TEST_CASE(identity_test)
{
    migraphx::program p;
309
310
311
312

    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
313
    auto prog = optimize_tf("identity_test.pb", false);
314
315
316
317

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
318
319
320
TEST_CASE(matmul_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
321

322
323
324
    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
325

326
327
328
329
    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
330
    auto prog = optimize_tf("matmul_test.pb", false);
Khalique's avatar
Khalique committed
331
332
333
334

    EXPECT(p == prog);
}

335
336
337
TEST_CASE(mean_test)
{
    migraphx::program p;
338
339

    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
340
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {2, 3}};
341
342
343
    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
344
    migraphx::op::reduce_mean op{{2, 3}};
345
346
347
    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
348
    auto prog = optimize_tf("mean_test.pb", false);
349
350
351
352
353
354
355

    EXPECT(p == prog);
}

TEST_CASE(mean_test_nhwc)
{
    migraphx::program p;
356
357

    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
358
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {1, 2}};
359
360
    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
361
    migraphx::op::reduce_mean op{{1, 2}};
362
363
    auto l2 = mm->add_instruction(op, l1);
    mm->add_instruction(migraphx::op::squeeze{{1, 2}}, l2);
Paul's avatar
Paul committed
364
    auto prog = optimize_tf("mean_test_nhwc.pb", true);
365
366
367
368

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
369
370
371
372
TEST_CASE(mul_test)
{
    migraphx::program p;

373
374
375
376
377
    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
378
    auto prog = optimize_tf("mul_test.pb", false);
Khalique's avatar
Khalique committed
379
380
381
382

    EXPECT(p == prog);
}

383
384
385
TEST_CASE(onehot_test)
{
    migraphx::program p;
386
387
388

    auto* mm = p.get_main_module();
    auto l0  = mm->add_literal(
Khalique's avatar
Khalique committed
389
        migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {5}}, {1, 1, 1, 1, 1}});
390
391
392
393
    mm->add_literal(2);
    mm->add_literal(1.0f);
    mm->add_literal(0.0f);
    auto l1 = mm->add_literal(
Khalique's avatar
Khalique committed
394
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {2, 2}}, {1, 0, 0, 1}});
395
    int axis = 0;
396
    mm->add_instruction(migraphx::op::gather{axis}, l1, l0);
397
398
399
400
401
    auto prog = optimize_tf("onehot_test.pb", false);

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
402
403
404
TEST_CASE(pack_test)
{
    migraphx::program p;
405
406
407
408
409

    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
410
411
412
413
    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
414
415
416
417
    std::transform(args.begin(),
                   args.end(),
                   std::back_inserter(unsqueezed_args),
                   [&](migraphx::instruction_ref arg) {
418
                       return mm->add_instruction(migraphx::op::unsqueeze{{axis}}, arg);
Khalique's avatar
Khalique committed
419
                   });
420
    mm->add_instruction(migraphx::op::concat{static_cast<int>(axis)}, unsqueezed_args);
Paul's avatar
Paul committed
421
    auto prog = optimize_tf("pack_test.pb", false);
Khalique's avatar
Khalique committed
422
423
424
425

    EXPECT(p == prog);
}

426
427
428
TEST_CASE(pack_test_nhwc)
{
    migraphx::program p;
429
430
431
432
433
434
435
436

    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
437
    std::vector<migraphx::instruction_ref> args{lt0, lt1, lt2};
438
    std::vector<migraphx::instruction_ref> unsqueezed_args;
Paul's avatar
Paul committed
439
    int64_t nchw_axis = 3;
440
441
442
443
444

    std::transform(args.begin(),
                   args.end(),
                   std::back_inserter(unsqueezed_args),
                   [&](migraphx::instruction_ref arg) {
445
                       return mm->add_instruction(migraphx::op::unsqueeze{{nchw_axis}}, arg);
446
                   });
447
    mm->add_instruction(migraphx::op::concat{static_cast<int>(nchw_axis)}, unsqueezed_args);
Paul's avatar
Paul committed
448
    auto prog = optimize_tf("pack_test_nhwc.pb", true);
449
450
451
452

    EXPECT(p == prog);
}

453
454
455
TEST_CASE(pooling_test)
{
    migraphx::program p;
456
457
458

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
459
460
    migraphx::op::pooling avg_pool_op{"average"};
    migraphx::op::pooling max_pool_op{"max"};
Shucai Xiao's avatar
Shucai Xiao committed
461
462
463
464
    avg_pool_op.stride  = {2, 2};
    max_pool_op.stride  = {2, 2};
    avg_pool_op.lengths = {2, 2};
    max_pool_op.lengths = {2, 2};
465
    mm->add_instruction(max_pool_op, l0);
Paul's avatar
Paul committed
466
    auto prog = optimize_tf("pooling_test.pb", true);
467
468
469
470

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
471
472
473
TEST_CASE(pow_test)
{
    migraphx::program p;
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, 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
479
480
481
482
483
    auto prog = optimize_tf("pow_test.pb", false);

    EXPECT(p == prog);
}

484
485
486
TEST_CASE(relu_test)
{
    migraphx::program p;
487
488
489
490

    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
491
    auto prog = optimize_tf("relu_test.pb", false);
492
493
494
495

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
496
497
498
TEST_CASE(relu6_test)
{
    migraphx::program p;
499
500

    auto* mm = p.get_main_module();
kahmed10's avatar
kahmed10 committed
501
    std::vector<size_t> input_lens{1, 3, 16, 16};
502
503
504
505
506
507
    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
508
    auto prog = optimize_tf("relu6_test.pb", false);
Khalique's avatar
Khalique committed
509
510
511
512

    EXPECT(p == prog);
}

513
514
515
TEST_CASE(reshape_test)
{
    migraphx::program p;
516
517
518

    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {16}});
519
520
    migraphx::shape s0{migraphx::shape::int32_type, {4}};
    // in tf, the second arg is a literal that contains new dimensions
521
522
    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
523
    auto prog = optimize_tf("reshape_test.pb", false);
524
525
526
527

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
528
529
530
TEST_CASE(rsqrt_test)
{
    migraphx::program p;
531
532
533
534

    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
535
536
537
538
539
    auto prog = optimize_tf("rsqrt_test.pb", false);

    EXPECT(p == prog);
}

540
541
542
TEST_CASE(shape_test)
{
    migraphx::program p;
543
544
545
546

    auto* mm = p.get_main_module();
    mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    mm->add_literal(
547
548
549
550
551
552
        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
553
554
555
TEST_CASE(slice_test)
{
    migraphx::program p;
556
557

    auto* mm             = p.get_main_module();
Khalique's avatar
Khalique committed
558
    std::size_t num_axes = 2;
559
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 10}});
Khalique's avatar
Khalique committed
560
    migraphx::shape s0{migraphx::shape::int32_type, {num_axes}};
561
562
    mm->add_literal(migraphx::literal{s0, {1, 0}});
    mm->add_literal(migraphx::literal{s0, {2, -1}});
Khalique's avatar
Khalique committed
563
564
565
566
567
568

    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);
569
    mm->add_instruction(op, l0);
Khalique's avatar
Khalique committed
570
571
572
573
574
    auto prog = optimize_tf("slice_test.pb", false);

    EXPECT(p == prog);
}

575
576
577
TEST_CASE(softmax_test)
{
    migraphx::program p;
578
579
580
581

    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
582
    auto prog = optimize_tf("softmax_test.pb", false);
583
584
585
586

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
587
588
589
TEST_CASE(split_test)
{
    migraphx::program p;
590
591

    auto* mm = p.get_main_module();
kahmed10's avatar
kahmed10 committed
592
    std::vector<int64_t> axes{0, 1};
593
594
595
596
597
598
599
600
601
602
    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
603

604
    auto prog = parse_tf("split_test.pb", false);
kahmed10's avatar
kahmed10 committed
605
606
607
608
609
610
611

    EXPECT(p == prog);
}

TEST_CASE(split_test_one_output)
{
    migraphx::program p;
612
613
614
615
616
617

    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
618

619
    auto prog = parse_tf("split_test_one_output.pb", false);
kahmed10's avatar
kahmed10 committed
620
621
622
623
624
625
626

    EXPECT(p == prog);
}

TEST_CASE(split_test_vector_as_input)
{
    migraphx::program p;
627
628

    auto* mm = p.get_main_module();
kahmed10's avatar
kahmed10 committed
629
    std::vector<int64_t> axes{0, 1};
630
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 30}});
kahmed10's avatar
kahmed10 committed
631
    // split sizes
632
    mm->add_literal(
kahmed10's avatar
kahmed10 committed
633
        migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {3}}, {4, 15, 11}});
634
635
636
637
638
639
640
641
    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
642

643
    auto prog = parse_tf("split_test_vector_as_input.pb", false);
kahmed10's avatar
kahmed10 committed
644
645
646
647

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
648
649
650
TEST_CASE(sqdiff_test)
{
    migraphx::program p;
651
652
653
654
655

    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
656
657
658
659
660
    auto prog = optimize_tf("sqdiff_test.pb", false);

    EXPECT(p == prog);
}

661
662
663
TEST_CASE(squeeze_test)
{
    migraphx::program p;
664
665
666
667

    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
668
    auto prog = optimize_tf("squeeze_test.pb", false);
669
670
671

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

Khalique's avatar
Khalique committed
673
674
675
TEST_CASE(stopgradient_test)
{
    migraphx::program p;
676
677
678
679

    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
680
681
    auto prog = optimize_tf("stopgradient_test.pb", false);

Khalique's avatar
Khalique committed
682
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
683
684
}

Khalique's avatar
Khalique committed
685
686
687
TEST_CASE(stridedslice_test)
{
    migraphx::program p;
688
689
690
691

    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
692
693
    std::size_t num_axes = 4;
    migraphx::op::slice op;
Khalique's avatar
Khalique committed
694
    op.starts = {0, 0, 0, 0};
Paul's avatar
Paul committed
695
    op.ends   = {1, 1, 1, 5};
Khalique's avatar
Khalique committed
696
697
    op.axes   = std::vector<int64_t>(num_axes);
    std::iota(op.axes.begin(), op.axes.end(), 0);
698
    auto l2          = mm->add_instruction(op, l1);
Paul's avatar
Paul committed
699
    auto shrink_axis = 1;
700
    mm->add_instruction(migraphx::op::squeeze{{shrink_axis}}, l2);
Paul's avatar
Paul committed
701
    auto prog = optimize_tf("stridedslice_test.pb", true);
Khalique's avatar
Khalique committed
702
703
704
705

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
706
707
708
TEST_CASE(stridedslice_masks_test)
{
    migraphx::program p;
709
710
711

    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
712
713
    std::size_t num_axes = 4;
    migraphx::op::slice op;
714
715
    op.starts = {0, 1, 1, 0};
    op.ends   = {1, 3, 3, 10};
Khalique's avatar
Khalique committed
716
717
718
    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)
719
720
721
722
723
724
725
726
727
728
    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);
729
    auto prog = parse_tf("stridedslice_masks_test.pb", true);
Khalique's avatar
Khalique committed
730
731
732
733

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
734
735
736
TEST_CASE(sub_test)
{
    migraphx::program p;
737
738
739
740
741

    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);
742
    auto prog = parse_tf("sub_test.pb", false);
Khalique's avatar
Khalique committed
743
744
745
746

    EXPECT(p == prog);
}

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

    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);
755
    auto prog = parse_tf("sub_test.pb", false);
Khalique's avatar
Khalique committed
756
757
758
759

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
760
761
762
TEST_CASE(transpose_test)
{
    migraphx::program p;
763
764
765

    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
766
    migraphx::shape s0{migraphx::shape::int32_type, {4}};
767
768
    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
769
770
771
772
773
    auto prog = optimize_tf("transpose_test.pb", false);

    EXPECT(p == prog);
}

774
775
776
TEST_CASE(variable_batch_test)
{
    migraphx::program p;
777
778
779
780

    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);
781
782
783
784
785
    auto prog = optimize_tf("variable_batch_test.pb", false);

    EXPECT(p == prog);
}

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