tf_test.cpp 15.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);
}

Khalique's avatar
Khalique committed
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
TEST_CASE(batchmatmul_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 8, 4}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 4, 8}});

    auto trans_l0 = p.add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l0);
    auto trans_l1 = p.add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l1);

    p.add_instruction(migraphx::op::dot{}, trans_l0, trans_l1);
    auto prog = optimize_tf("batchmatmul_test.pb", false);

    EXPECT(p == prog);
}

66
67
TEST_CASE(batchnorm_test)
{
Khalique's avatar
Khalique committed
68
69
    float epsilon  = 1.001e-5f;
    float momentum = 0.9f;
70
71

    migraphx::program p;
Khalique's avatar
Khalique committed
72
73
    migraphx::op::batch_norm_inference op{
        epsilon, momentum, migraphx::op::batch_norm_inference::spatial};
74
    migraphx::shape s0{migraphx::shape::float_type, {32}};
75
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 32, 16, 16}});
76
77
    std::vector<float> const_vals(32);
    std::fill(const_vals.begin(), const_vals.end(), 1.0f);
Khalique's avatar
Khalique committed
78

79
80
81
82
83
    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
84
    auto prog = optimize_tf("batchnorm_test.pb", true);
85
86
87
88

    EXPECT(p == prog);
}

89
90
91
TEST_CASE(biasadd_test)
{
    migraphx::program p;
92
    migraphx::shape s0{migraphx::shape::float_type, {1, 500, 1, 1}};
93
    uint64_t axis = 1;
Khalique's avatar
Khalique committed
94
    auto l0       = p.add_parameter("0", s0);
95
    auto l1       = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {500}});
96
    auto l2       = p.add_instruction(migraphx::op::broadcast{axis, l0->get_shape().lens()}, l1);
97
    p.add_instruction(migraphx::op::add{}, l0, l2);
Paul's avatar
Paul committed
98
    auto prog = optimize_tf("biasadd_test.pb", true);
99
100
101
102

    EXPECT(p == prog);
}

103
104
105
TEST_CASE(concat_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
106

107
108
109
110
111
    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
112
    // add the literal using a vector in order to set stride to 1 (like in tf parser)
113
    p.add_literal(migraphx::shape{migraphx::shape::int32_type}, std::vector<int>{axis});
114
115

    p.add_instruction(migraphx::op::concat{static_cast<std::size_t>(axis)}, l0, l1);
Paul's avatar
Paul committed
116
    auto prog = optimize_tf("concat_test.pb", false);
117
118
119
120
121
122
123

    EXPECT(p == prog);
}

TEST_CASE(const_test)
{
    migraphx::program p;
124
    p.add_literal(migraphx::shape{migraphx::shape::float_type}, std::vector<float>{1.0f});
Paul's avatar
Paul committed
125
    auto prog = optimize_tf("constant_test.pb", false);
126
127
128
129
130
131
132

    EXPECT(p == prog);
}

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

134
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
Khalique's avatar
Khalique committed
135
    std::vector<float> weight_data(3 * 3 * 3 * 32);
136
    std::fill(weight_data.begin(), weight_data.end(), 1.0f);
Khalique's avatar
Khalique committed
137
138
    auto l1 =
        p.add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 32}}, weight_data);
139
140
141

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
Khalique's avatar
Khalique committed
142
    op.padding      = {1, 1};
Khalique's avatar
Khalique committed
143
144
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
Paul's avatar
Paul committed
145
146
147
    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);
148
149
150
151

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
152
153
154
155
156
157
158
159
160
161
162
163
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
164
    op.padding      = {1, 1};
Khalique's avatar
Khalique committed
165
166
167
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
    op.group        = 3;
Paul's avatar
Paul committed
168
    auto l3         = p.add_instruction(migraphx::op::transpose{{3, 2, 0, 1}}, l1);
Paul's avatar
Paul committed
169
170
171
    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
172
    auto prog = optimize_tf("depthwise_conv_test.pb", true);
Khalique's avatar
Khalique committed
173
174
175
176

    EXPECT(p == prog);
}

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

    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4}});
182
    p.add_literal(0);
Khalique's avatar
Khalique committed
183
    p.add_instruction(migraphx::op::reshape{{1, 2, 3, 4}}, l0);
184
    auto prog = optimize_tf("expanddims_test.pb", false);
Khalique's avatar
Khalique committed
185
186
187
188
189
190
191
192
193
194

    EXPECT(p == prog);
}

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

    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4}});
195
    p.add_literal(-1);
Khalique's avatar
Khalique committed
196
    p.add_instruction(migraphx::op::reshape{{2, 3, 4, 1}}, l0);
197
    auto prog = optimize_tf("expanddims_neg_test.pb", false);
Khalique's avatar
Khalique committed
198
199
200
201

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
212
213
214
215
216
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
217
218
219

    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
220
221

    p.add_instruction(migraphx::op::dot{}, trans_l0, trans_l1);
Paul's avatar
Paul committed
222
    auto prog = optimize_tf("matmul_test.pb", false);
Khalique's avatar
Khalique committed
223
224
225
226

    EXPECT(p == prog);
}

227
228
229
TEST_CASE(mean_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
230
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {2, 3}};
231
232
233
234
    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
235
    op.lengths = {16, 16};
Paul's avatar
Paul committed
236
    p.add_instruction(op, l0);
Paul's avatar
Paul committed
237
    auto l3 = p.add_instruction(op, l0);
Khalique's avatar
Khalique committed
238
    p.add_instruction(migraphx::op::squeeze{{2, 3}}, l3);
Paul's avatar
Paul committed
239
    auto prog = optimize_tf("mean_test.pb", false);
240
241
242
243
244
245
246

    EXPECT(p == prog);
}

TEST_CASE(mean_test_nhwc)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
247
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {1, 2}};
248
249
    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
250
251
252
    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
253
    auto prog = optimize_tf("mean_test_nhwc.pb", true);
254
255
256
257

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
258
259
260
TEST_CASE(mul_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
261
262
    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
263
264

    p.add_instruction(migraphx::op::mul{}, l0, l1);
Paul's avatar
Paul committed
265
    auto prog = optimize_tf("mul_test.pb", false);
Khalique's avatar
Khalique committed
266
267
268
269

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
270
271
272
273
274
275
276
277
278
279
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
280
281
282
283
284
285
    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
286
    p.add_instruction(migraphx::op::concat{static_cast<size_t>(axis)}, unsqueezed_args);
Paul's avatar
Paul committed
287
    auto prog = optimize_tf("pack_test.pb", false);
Khalique's avatar
Khalique committed
288
289
290
291

    EXPECT(p == prog);
}

292
293
294
TEST_CASE(pack_test_nhwc)
{
    migraphx::program p;
Paul's avatar
Paul committed
295
    auto l0  = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
Paul's avatar
Paul committed
296
    auto lt0 = p.add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l0);
Paul's avatar
Paul committed
297
    auto l1  = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
Paul's avatar
Paul committed
298
    auto lt1 = p.add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l1);
Paul's avatar
Paul committed
299
    auto l2  = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
Paul's avatar
Paul committed
300
301
    auto lt2 = p.add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l2);
    std::vector<migraphx::instruction_ref> args{lt0, lt1, lt2};
302
    std::vector<migraphx::instruction_ref> unsqueezed_args;
Paul's avatar
Paul committed
303
    int64_t nchw_axis = 3;
304
305
306
307
308
309
310
311

    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
312
    auto prog = optimize_tf("pack_test_nhwc.pb", true);
313
314
315
316

    EXPECT(p == prog);
}

317
318
319
TEST_CASE(pooling_test)
{
    migraphx::program p;
320
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
321
322
323
324
    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
325
326
327
328
    avg_pool_op.stride       = {2, 2};
    max_pool_op.stride       = {2, 2};
    avg_pool_op.lengths      = {2, 2};
    max_pool_op.lengths      = {2, 2};
329
    p.add_instruction(max_pool_op, l0);
Paul's avatar
Paul committed
330
331
    // p.add_instruction(avg_pool_op, l0);
    auto prog = optimize_tf("pooling_test.pb", true);
332
333
334
335

    EXPECT(p == prog);
}

336
337
338
339
340
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
341
    auto prog = optimize_tf("relu_test.pb", false);
342
343
344
345

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
346
347
348
349
350
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
351
    auto prog = optimize_tf("relu6_test.pb", false);
Khalique's avatar
Khalique committed
352
353
354
355

    EXPECT(p == prog);
}

356
357
358
359
360
361
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
362
363
    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
364
    auto prog = optimize_tf("reshape_test.pb", false);
365
366
367
368
369
370
371

    EXPECT(p == prog);
}

TEST_CASE(softmax_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
372
    auto l0   = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
373
    auto dims = l0->get_shape().lens();
Khalique's avatar
Khalique committed
374
375
    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);
376
    p.add_instruction(migraphx::op::reshape{{long(dims[0]), long(dims[1])}}, s);
Paul's avatar
Paul committed
377
    auto prog = optimize_tf("softmax_test.pb", false);
378
379
380
381

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
382
383
384
385
386
387
388
389
390
391
392
TEST_CASE(sqdiff_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::sqdiff{}, l0, l1);
    auto prog = optimize_tf("sqdiff_test.pb", false);

    EXPECT(p == prog);
}

393
394
395
TEST_CASE(squeeze_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
396
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 3, 1}});
397
    p.add_instruction(migraphx::op::squeeze{{0, 3}}, l0);
Paul's avatar
Paul committed
398
    auto prog = optimize_tf("squeeze_test.pb", false);
399
400
401

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

Khalique's avatar
Khalique committed
403
404
405
406
407
408
409
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
410
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
411
412
}

Khalique's avatar
Khalique committed
413
414
415
416
417
418
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
419
    op.starts = {0, 0, 0, 0};
Paul's avatar
Paul committed
420
    op.ends   = {1, 1, 1, 5};
Khalique's avatar
Khalique committed
421
422
    op.axes   = std::vector<int64_t>(num_axes);
    std::iota(op.axes.begin(), op.axes.end(), 0);
Khalique's avatar
Khalique committed
423
    auto l1          = p.add_instruction(op, l0);
Paul's avatar
Paul committed
424
    auto shrink_axis = 1;
Khalique's avatar
Khalique committed
425
    p.add_instruction(migraphx::op::squeeze{{shrink_axis}}, l1);
Paul's avatar
Paul committed
426
    auto prog = optimize_tf("stridedslice_test.pb", true);
Khalique's avatar
Khalique committed
427
428
429
430

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
431
432
433
434
435
436
437
438
439
440
441
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
442
443
444
TEST_CASE(tanh_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
445
446
447
448
    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
449
450
451
452

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
453
454
455
456
457
TEST_CASE(transpose_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    migraphx::shape s0{migraphx::shape::int32_type, {4}};
Khalique's avatar
Khalique committed
458
459
    p.add_literal(migraphx::literal{s0, {0, 2, 3, 1}});
    p.add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l0);
Khalique's avatar
Khalique committed
460
461
462
463
464
    auto prog = optimize_tf("transpose_test.pb", false);

    EXPECT(p == prog);
}

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