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

Paul's avatar
Paul committed
14
15
16
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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
106
107
108
109
110
111
112
113
114
115
TEST_CASE(cast_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::convert{migraphx::shape::int32_type}, l0);
    auto prog = optimize_tf("cast_test.pb", false);

    EXPECT(p == prog);
}

116
117
118
TEST_CASE(const_test)
{
    migraphx::program p;
119
    p.add_literal(migraphx::shape{migraphx::shape::float_type}, std::vector<float>{1.0f});
Paul's avatar
Paul committed
120
    auto prog = optimize_tf("constant_test.pb", false);
121
122
123
124
125
126
127

    EXPECT(p == prog);
}

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

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

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
Khalique's avatar
Khalique committed
137
    op.padding      = {1, 1};
Khalique's avatar
Khalique committed
138
139
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
Paul's avatar
Paul committed
140
141
142
    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);
143
144
145
146

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
172
173
174
TEST_CASE(expanddims_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
175
176

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

    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}});
190
    p.add_literal(-1);
Khalique's avatar
Khalique committed
191
    p.add_instruction(migraphx::op::reshape{{2, 3, 4, 1}}, l0);
192
    auto prog = optimize_tf("expanddims_neg_test.pb", false);
Khalique's avatar
Khalique committed
193
194
195
196

    EXPECT(p == prog);
}

197
198
199
200
201
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
202
    auto prog = optimize_tf("identity_test.pb", false);
203
204
205
206

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
207
208
209
210
211
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
212
213
214

    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
215
216

    p.add_instruction(migraphx::op::dot{}, trans_l0, trans_l1);
Paul's avatar
Paul committed
217
    auto prog = optimize_tf("matmul_test.pb", false);
Khalique's avatar
Khalique committed
218
219
220
221

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
253
254
255
TEST_CASE(mul_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
256
257
    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
258
259

    p.add_instruction(migraphx::op::mul{}, l0, l1);
Paul's avatar
Paul committed
260
    auto prog = optimize_tf("mul_test.pb", false);
Khalique's avatar
Khalique committed
261
262
263
264

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

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

    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
307
    auto prog = optimize_tf("pack_test_nhwc.pb", true);
308
309
310
311

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

331
332
333
334
335
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
336
    auto prog = optimize_tf("relu_test.pb", false);
337
338
339
340

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
341
342
343
344
345
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
346
    auto prog = optimize_tf("relu6_test.pb", false);
Khalique's avatar
Khalique committed
347
348
349
350

    EXPECT(p == prog);
}

351
352
353
354
355
356
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
357
358
    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
359
    auto prog = optimize_tf("reshape_test.pb", false);
360
361
362
363
364
365
366

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
377
378
379
380
381
382
383
384
385
386
387
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);
}

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

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

Khalique's avatar
Khalique committed
398
399
400
401
402
403
404
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
405
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
406
407
}

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

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
448
449
450
451
452
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
453
454
    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
455
456
457
458
459
    auto prog = optimize_tf("transpose_test.pb", false);

    EXPECT(p == prog);
}

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