onnx_test.cpp 59.7 KB
Newer Older
Scott Thornton's avatar
Scott Thornton committed
1
2
#include <iostream>
#include <vector>
Paul's avatar
Paul committed
3
4
5
6
#include <migraphx/literal.hpp>
#include <migraphx/operators.hpp>
#include <migraphx/program.hpp>
#include <migraphx/instruction.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
7
#include <migraphx/instruction_ref.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
8
9
10
#include <migraphx/pass_manager.hpp>
#include <migraphx/dead_code_elimination.hpp>
#include <migraphx/eliminate_identity.hpp>
Paul's avatar
Paul committed
11
#include <migraphx/onnx.hpp>
Scott Thornton's avatar
Scott Thornton committed
12
13
#include "test.hpp"

Shucai Xiao's avatar
Shucai Xiao committed
14
15
16
17
18
19
20
21
migraphx::program optimize_onnx(const std::string& name, bool eliminate_deadcode = false)
{
    auto prog = migraphx::parse_onnx(name);
    if(eliminate_deadcode)
        migraphx::run_passes(prog, {migraphx::dead_code_elimination{}});

    // remove the last identity instruction
    auto last_ins = std::prev(prog.end());
22
    if(last_ins->name() == "@return")
Shucai Xiao's avatar
Shucai Xiao committed
23
24
25
26
27
28
29
    {
        prog.remove_instruction(last_ins);
    }

    return prog;
}

Khalique's avatar
Khalique committed
30
TEST_CASE(acos_test)
Scott Thornton's avatar
Scott Thornton committed
31
{
Paul's avatar
Paul committed
32
    migraphx::program p;
Khalique's avatar
Khalique committed
33
34
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::acos{}, input);
Scott Thornton's avatar
Scott Thornton committed
35

Shucai Xiao's avatar
Shucai Xiao committed
36
    auto prog = optimize_onnx("acos_test.onnx");
Scott Thornton's avatar
Scott Thornton committed
37
38
39
40

    EXPECT(p == prog);
}

41
42
43
44
45
46
47
48
49
50
51
TEST_CASE(acosh_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::acosh{}, input);

    auto prog = optimize_onnx("acosh_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
52
TEST_CASE(add_bcast_test)
53
{
Paul's avatar
Paul committed
54
    migraphx::program p;
Khalique's avatar
Khalique committed
55
56
57
58
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}});
    auto l2 = p.add_instruction(migraphx::op::broadcast{1, l0->get_shape().lens()}, l1);
    p.add_instruction(migraphx::op::add{}, l0, l2);
Paul's avatar
Paul committed
59

Shucai Xiao's avatar
Shucai Xiao committed
60
    auto prog = optimize_onnx("add_bcast_test.onnx");
Paul's avatar
Paul committed
61

62
63
64
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
65
TEST_CASE(add_fp16_test)
Scott Thornton's avatar
Scott Thornton committed
66
{
Paul's avatar
Paul committed
67
    migraphx::program p;
Khalique's avatar
Khalique committed
68
69
70
71
72
    auto l0 =
        p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type, {1}}, {1.5}});
    auto l1 =
        p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type, {1}}, {2.5}});
    p.add_instruction(migraphx::op::add{}, l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
73
    auto prog = optimize_onnx("add_fp16_test.onnx");
Scott Thornton's avatar
Scott Thornton committed
74
75
76
77

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
78
TEST_CASE(add_scalar_test)
79
{
Paul's avatar
Paul committed
80
    migraphx::program p;
81
82
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::uint8_type, {2, 3, 4, 5}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::uint8_type});
Khalique's avatar
Khalique committed
83
    auto m1 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
84
85
86
    auto r  = p.add_instruction(migraphx::op::add{}, l0, m1);
    p.add_return({r});
    auto prog = migraphx::parse_onnx("add_scalar_test.onnx");
87
88
89
90

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
91
TEST_CASE(argmax_test)
Khalique's avatar
Khalique committed
92
{
Paul's avatar
Paul committed
93
    migraphx::program p;
Khalique's avatar
Khalique committed
94
95
96
    auto l0  = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto ins = p.add_instruction(migraphx::op::argmax{2}, l0);
    p.add_instruction(migraphx::op::squeeze{{2}}, ins);
Shucai Xiao's avatar
Shucai Xiao committed
97
    auto prog = optimize_onnx("argmax_test.onnx");
Khalique's avatar
Khalique committed
98
99
100
101

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
102
TEST_CASE(argmin_test)
103
{
Paul's avatar
Paul committed
104
    migraphx::program p;
Khalique's avatar
Khalique committed
105
106
107
    auto l0  = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto ins = p.add_instruction(migraphx::op::argmin{3}, l0);
    p.add_instruction(migraphx::op::squeeze{{3}}, ins);
Shucai Xiao's avatar
Shucai Xiao committed
108
    auto prog = optimize_onnx("argmin_test.onnx");
109
110
111
112

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
113
TEST_CASE(asin_test)
114
{
Paul's avatar
Paul committed
115
    migraphx::program p;
Khalique's avatar
Khalique committed
116
117
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::asin{}, input);
118

Shucai Xiao's avatar
Shucai Xiao committed
119
    auto prog = optimize_onnx("asin_test.onnx");
120
121
122
123

    EXPECT(p == prog);
}

124
125
126
127
128
129
130
131
132
133
134
TEST_CASE(asinh_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::asinh{}, input);

    auto prog = optimize_onnx("asinh_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
135
TEST_CASE(atan_test)
Khalique's avatar
Khalique committed
136
{
Paul's avatar
Paul committed
137
    migraphx::program p;
Khalique's avatar
Khalique committed
138
139
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::atan{}, input);
Khalique's avatar
Khalique committed
140

Shucai Xiao's avatar
Shucai Xiao committed
141
    auto prog = optimize_onnx("atan_test.onnx");
Khalique's avatar
Khalique committed
142
143
144
145

    EXPECT(p == prog);
}

146
147
148
149
150
151
152
153
154
155
156
TEST_CASE(atanh_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::atanh{}, input);

    auto prog = optimize_onnx("atanh_test.onnx");

    EXPECT(p == prog);
}

157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
TEST_CASE(averagepool_notset_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
    auto ins_pad              = p.add_instruction(migraphx::op::pad{pads}, input);
    p.add_instruction(migraphx::op::pooling{"average", {0, 0}, {2, 2}, {6, 6}}, ins_pad);

    auto prog = optimize_onnx("averagepool_notset_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(averagepool_same_lower_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
    std::vector<int64_t> pads = {0, 0, 1, 1, 0, 0, 0, 0};
    auto ins_pad              = p.add_instruction(migraphx::op::pad{pads}, input);
    p.add_instruction(
        migraphx::op::pooling{
            "average", {0, 0}, {1, 1}, {2, 2}, migraphx::op::padding_mode_t::same},
        ins_pad);

    auto prog = optimize_onnx("averagepool_same_lower_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(averagepool_same_upper_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
    auto ins_pad              = p.add_instruction(migraphx::op::pad{pads}, input);
    p.add_instruction(
        migraphx::op::pooling{
            "average", {0, 0}, {1, 1}, {2, 2}, migraphx::op::padding_mode_t::same},
        ins_pad);

    auto prog = optimize_onnx("averagepool_same_upper_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
202
TEST_CASE(cast_test)
Khalique's avatar
Khalique committed
203
{
Paul's avatar
Paul committed
204
    migraphx::program p;
Khalique's avatar
Khalique committed
205
206
    auto l = p.add_parameter("x", migraphx::shape{migraphx::shape::half_type, {10}});
    p.add_instruction(migraphx::op::convert{migraphx::shape::float_type}, l);
Khalique's avatar
Khalique committed
207

Shucai Xiao's avatar
Shucai Xiao committed
208
    auto prog = optimize_onnx("cast_test.onnx");
Khalique's avatar
Khalique committed
209
210
211
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
212
213
214
215
216
217
TEST_CASE(ceil_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::ceil{}, input);

Shucai Xiao's avatar
Shucai Xiao committed
218
    auto prog = optimize_onnx("ceil_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
219
220
221
222

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
223
TEST_CASE(clip_test)
Khalique's avatar
Khalique committed
224
225
{
    migraphx::program p;
kahmed10's avatar
kahmed10 committed
226
227
228
229
230
231
    auto l0      = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    auto min_val = p.add_literal(0.0f);
    auto max_val = p.add_literal(6.0f);
    min_val      = p.add_instruction(migraphx::op::multibroadcast{{3}}, min_val);
    max_val      = p.add_instruction(migraphx::op::multibroadcast{{3}}, max_val);
    p.add_instruction(migraphx::op::clip{}, l0, min_val, max_val);
Shucai Xiao's avatar
Shucai Xiao committed
232
    auto prog = optimize_onnx("clip_test.onnx");
Khalique's avatar
Khalique committed
233

234
235
236
    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
TEST_CASE(clip_test_op11)
{
    migraphx::program p;
    auto min_val = p.add_literal(0.0f);
    auto max_val = p.add_literal(6.0f);
    auto l0      = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    min_val      = p.add_instruction(migraphx::op::multibroadcast{{3}}, min_val);
    max_val      = p.add_instruction(migraphx::op::multibroadcast{{3}}, max_val);
    p.add_instruction(migraphx::op::clip{}, l0, min_val, max_val);
    auto prog = optimize_onnx("clip_test_op11.onnx");

    EXPECT(p == prog);
}

TEST_CASE(clip_test_op11_min_only)
{
    migraphx::program p;
    auto min_val = p.add_literal(0.0f);
    auto l0      = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    min_val      = p.add_instruction(migraphx::op::multibroadcast{{3}}, min_val);
    p.add_instruction(migraphx::op::max{}, l0, min_val);
    auto prog = optimize_onnx("clip_test_op11_min_only.onnx");

    EXPECT(p == prog);
}

TEST_CASE(clip_test_op11_no_args)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    p.add_instruction(migraphx::op::identity{}, l0);
    auto prog = optimize_onnx("clip_test_op11_no_args.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
273
TEST_CASE(concat_test)
Shucai Xiao's avatar
Shucai Xiao committed
274
275
{
    migraphx::program p;
Khalique's avatar
Khalique committed
276
277
278
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 4, 3}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7, 4, 3}});
    p.add_instruction(migraphx::op::concat{0}, l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
279
    auto prog = optimize_onnx("concat_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
280
281
282
283

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
284
TEST_CASE(constant_test)
Shucai Xiao's avatar
Shucai Xiao committed
285
286
{
    migraphx::program p;
Khalique's avatar
Khalique committed
287
    p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0, 1, 2}});
Shucai Xiao's avatar
Shucai Xiao committed
288
    auto prog = optimize_onnx("constant_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
289
290
291
292

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
293
TEST_CASE(constant_fill_test)
Shucai Xiao's avatar
Shucai Xiao committed
294
{
Khalique's avatar
Khalique committed
295
296
297
298
299

    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
    std::vector<float> value(s.elements(), 1.0);
    p.add_literal(migraphx::literal{s, value});
Shucai Xiao's avatar
Shucai Xiao committed
300
    auto prog = optimize_onnx("constant_fill_test.onnx");
Khalique's avatar
Khalique committed
301
302
303
304
305
306
307
308
309
310
311
312
313
314

    EXPECT(p == prog);
}

TEST_CASE(constant_fill_input_as_shape_test)
{
    migraphx::program p;
    auto l0 = p.add_literal(migraphx::literal{{migraphx::shape::int32_type, {2}}, {2, 3}});
    std::vector<std::size_t> dims(l0->get_shape().elements());
    migraphx::literal ls = l0->get_literal();
    ls.visit([&](auto s) { dims.assign(s.begin(), s.end()); });
    migraphx::shape s{migraphx::shape::float_type, dims};
    std::vector<float> value(s.elements(), 1.0);
    p.add_literal(migraphx::literal{s, value});
Shucai Xiao's avatar
Shucai Xiao committed
315
    auto prog = optimize_onnx("constant_fill_input_as_shape_test.onnx");
Khalique's avatar
Khalique committed
316
317

    EXPECT(p == prog);
Shucai Xiao's avatar
Shucai Xiao committed
318
319
}

Khalique's avatar
Khalique committed
320
TEST_CASE(constant_scalar_test)
321
322
{
    migraphx::program p;
Khalique's avatar
Khalique committed
323
    p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {1}}, {1}});
Shucai Xiao's avatar
Shucai Xiao committed
324
    auto prog = optimize_onnx("constant_scalar_test.onnx");
325
326
327
328

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
329
TEST_CASE(const_of_shape_empty_input_test)
Shucai Xiao's avatar
Shucai Xiao committed
330
331
{
    migraphx::program p;
Khalique's avatar
Khalique committed
332
333
334
335
    p.add_literal(migraphx::literal());
    migraphx::shape s(migraphx::shape::int64_type, {1}, {0});
    std::vector<int64_t> vec(s.elements(), 10);
    p.add_literal(migraphx::literal(s, vec));
Shucai Xiao's avatar
Shucai Xiao committed
336

Shucai Xiao's avatar
Shucai Xiao committed
337
    auto prog = optimize_onnx("const_of_shape_empty_input_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
338
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
339
340
}

Khalique's avatar
Khalique committed
341
TEST_CASE(const_of_shape_float_test)
342
343
{
    migraphx::program p;
Khalique's avatar
Khalique committed
344
345
346
347
348
    migraphx::shape ss(migraphx::shape::int32_type, {3});
    p.add_literal(migraphx::literal(ss, {2, 3, 4}));
    migraphx::shape s(migraphx::shape::float_type, {2, 3, 4});
    std::vector<float> vec(s.elements(), 10.0f);
    p.add_literal(migraphx::literal(s, vec));
349

Shucai Xiao's avatar
Shucai Xiao committed
350
    auto prog = optimize_onnx("const_of_shape_float_test.onnx");
351
352
353
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
354
TEST_CASE(const_of_shape_int64_test)
355
356
{
    migraphx::program p;
Khalique's avatar
Khalique committed
357
358
359
360
361
    migraphx::shape ss(migraphx::shape::int32_type, {3});
    p.add_literal(migraphx::literal(ss, {2, 3, 4}));
    migraphx::shape s(migraphx::shape::int64_type, {2, 3, 4});
    std::vector<int64_t> vec(s.elements(), 10);
    p.add_literal(migraphx::literal(s, vec));
362

Shucai Xiao's avatar
Shucai Xiao committed
363
    auto prog = optimize_onnx("const_of_shape_int64_test.onnx");
364
365
366
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
367
TEST_CASE(const_of_shape_no_value_attr_test)
368
369
{
    migraphx::program p;
Khalique's avatar
Khalique committed
370
371
372
373
374
    migraphx::shape ss(migraphx::shape::int32_type, {3});
    p.add_literal(migraphx::literal(ss, {2, 3, 4}));
    migraphx::shape s(migraphx::shape::float_type, {2, 3, 4});
    std::vector<float> vec(s.elements(), 0.0f);
    p.add_literal(migraphx::literal(s, vec));
375

Shucai Xiao's avatar
Shucai Xiao committed
376
    auto prog = optimize_onnx("const_of_shape_no_value_attr_test.onnx");
377
378
379
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
380
TEST_CASE(conv_autopad_fail_test)
381
{
Shucai Xiao's avatar
Shucai Xiao committed
382
    EXPECT(test::throws([&] { optimize_onnx("conv_autopad_fail_test.onnx"); }));
Khalique's avatar
Khalique committed
383
}
384

385
386
387
388
389
390
391
392
393
394
395
396
397
398
TEST_CASE(conv_autopad_same_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
    auto l1 = p.add_parameter("1", {migraphx::shape::float_type, {1, 3, 3, 3}});
    migraphx::op::convolution op;
    op.padding      = {1, 1};
    op.padding_mode = migraphx::op::padding_mode_t::same;
    p.add_instruction(op, l0, l1);

    auto prog = optimize_onnx("conv_autopad_same_test.onnx");
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
399
400
401
402
403
404
405
406
407
408
409
TEST_CASE(conv_bias_test)
{
    migraphx::program p;
    auto l0       = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
    auto l1       = p.add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}});
    auto l2       = p.add_parameter("2", {migraphx::shape::float_type, {1}});
    uint64_t axis = 1;
    auto l3       = p.add_instruction(migraphx::op::convolution{}, l0, l1);
    auto l4       = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
    p.add_instruction(migraphx::op::add{}, l3, l4);

Shucai Xiao's avatar
Shucai Xiao committed
410
    auto prog = optimize_onnx("conv_bias_test.onnx");
Khalique's avatar
Khalique committed
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
    EXPECT(p == prog);
}

TEST_CASE(conv_bn_relu_maxpool_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
    auto l1 = p.add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}});
    auto l2 = p.add_parameter("2", {migraphx::shape::float_type, {1}});

    auto p3       = p.add_parameter("3", {migraphx::shape::float_type, {1}});
    auto p4       = p.add_parameter("4", {migraphx::shape::float_type, {1}});
    auto p5       = p.add_parameter("5", {migraphx::shape::float_type, {1}});
    auto p6       = p.add_parameter("6", {migraphx::shape::float_type, {1}});
    uint64_t axis = 1;
    auto l3       = p.add_instruction(migraphx::op::convolution{}, l0, l1);
    auto l4       = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
    auto l5       = p.add_instruction(migraphx::op::add{}, l3, l4);
    auto l6 = p.add_instruction(migraphx::op::batch_norm_inference{1.0e-5f}, l5, p3, p4, p5, p6);
    auto l7 = p.add_instruction(migraphx::op::relu{}, l6);
    p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l7);

Shucai Xiao's avatar
Shucai Xiao committed
433
    auto prog = optimize_onnx("conv_bn_relu_maxpool_test.onnx");
Khalique's avatar
Khalique committed
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
    EXPECT(p == prog);
}

TEST_CASE(conv_relu_maxpool_test)
{
    migraphx::program p;
    auto l0       = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
    auto l1       = p.add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}});
    auto l2       = p.add_parameter("2", {migraphx::shape::float_type, {1}});
    uint64_t axis = 1;
    auto l3       = p.add_instruction(migraphx::op::convolution{}, l0, l1);
    auto l4       = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
    auto l5       = p.add_instruction(migraphx::op::add{}, l3, l4);
    auto l6       = p.add_instruction(migraphx::op::relu{}, l5);
    p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l6);

Shucai Xiao's avatar
Shucai Xiao committed
450
    auto prog = optimize_onnx("conv_relu_maxpool_test.onnx");
Khalique's avatar
Khalique committed
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
    EXPECT(p == prog);
}

TEST_CASE(conv_relu_maxpool_x2_test)
{
    migraphx::program p;
    auto l0       = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
    auto l1       = p.add_parameter("1", {migraphx::shape::float_type, {5, 3, 5, 5}});
    auto l2       = p.add_parameter("2", {migraphx::shape::float_type, {5}});
    uint64_t axis = 1;
    auto l3       = p.add_instruction(migraphx::op::convolution{}, l0, l1);
    auto l4       = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
    auto l5       = p.add_instruction(migraphx::op::add{}, l3, l4);
    auto l6       = p.add_instruction(migraphx::op::relu{}, l5);
    auto l7 = p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l6);

    auto l8  = p.add_parameter("3", {migraphx::shape::float_type, {1, 5, 5, 5}});
    auto l9  = p.add_parameter("4", {migraphx::shape::float_type, {1}});
    auto l10 = p.add_instruction(migraphx::op::convolution{}, l7, l8);
    auto l11 = p.add_instruction(migraphx::op::broadcast{axis, l10->get_shape().lens()}, l9);
    auto l12 = p.add_instruction(migraphx::op::add{}, l10, l11);
    auto l13 = p.add_instruction(migraphx::op::relu{}, l12);
    p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l13);

Shucai Xiao's avatar
Shucai Xiao committed
475
    auto prog = optimize_onnx("conv_relu_maxpool_x2_test.onnx");
Khalique's avatar
Khalique committed
476
477
478
479

    EXPECT(p == prog);
}

480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
TEST_CASE(convinteger_bias_test)
{
    migraphx::program p;
    auto l0       = p.add_parameter("0", {migraphx::shape::int8_type, {1, 3, 32, 32}});
    auto l1       = p.add_parameter("1", {migraphx::shape::int8_type, {1, 3, 5, 5}});
    auto l2       = p.add_parameter("2", {migraphx::shape::int32_type, {1}});
    uint64_t axis = 1;
    auto l3       = p.add_instruction(migraphx::op::quant_convolution{}, l0, l1);
    auto l4       = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
    p.add_instruction(migraphx::op::add{}, l3, l4);

    auto prog = optimize_onnx("convinteger_bias_test.onnx");
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
495
TEST_CASE(cos_test)
496
497
498
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
Khalique's avatar
Khalique committed
499
    p.add_instruction(migraphx::op::cos{}, input);
500

Shucai Xiao's avatar
Shucai Xiao committed
501
    auto prog = optimize_onnx("cos_test.onnx");
502
503
504
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
505
TEST_CASE(cosh_test)
506
507
508
509
510
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}});
    p.add_instruction(migraphx::op::cosh{}, input);

Shucai Xiao's avatar
Shucai Xiao committed
511
    auto prog = optimize_onnx("cosh_test.onnx");
512
513
514
515

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
TEST_CASE(deconv_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1 = p.add_parameter("w", {migraphx::shape::float_type, {1, 1, 3, 3}});
    p.add_instruction(migraphx::op::deconvolution{}, l0, l1);

    auto prog = optimize_onnx("deconv_test.onnx");
    EXPECT(p == prog);
}

TEST_CASE(deconv_bias_test)
{
    migraphx::program p;
    auto l0       = p.add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1       = p.add_parameter("w", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l2       = p.add_parameter("b", {migraphx::shape::float_type, {1}});
    uint64_t axis = 1;
    auto l3       = p.add_instruction(migraphx::op::deconvolution{}, l0, l1);
    auto l4       = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
    p.add_instruction(migraphx::op::add{}, l3, l4);

    auto prog = optimize_onnx("deconv_bias_test.onnx");
    EXPECT(p == prog);
}

TEST_CASE(deconv_input_pads_strides_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1 = p.add_parameter("w", {migraphx::shape::float_type, {1, 2, 3, 3}});
    p.add_instruction(migraphx::op::deconvolution{{1, 1}, {3, 2}}, l0, l1);

    auto prog = optimize_onnx("deconv_input_pads_strides_test.onnx");
    EXPECT(p == prog);
}

TEST_CASE(deconv_input_pads_asymm_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1 = p.add_parameter("w", {migraphx::shape::float_type, {1, 2, 3, 3}});
    auto l2 = p.add_instruction(migraphx::op::deconvolution{{0, 0}, {3, 2}}, l0, l1);
    p.add_instruction(migraphx::op::slice{{0, 1, 2, 3}, {0, 0, 0, 0}, {1, 2, 8, 6}}, l2);

    auto prog = optimize_onnx("deconv_input_pads_asymm_test.onnx");
    EXPECT(p == prog);
}

TEST_CASE(deconv_output_shape_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1 = p.add_parameter("w", {migraphx::shape::float_type, {1, 2, 3, 3}});
    auto l2 = p.add_instruction(migraphx::op::deconvolution{{0, 0}, {3, 2}}, l0, l1);
    p.add_instruction(migraphx::op::pad{{0, 0, 0, 0, 0, 0, 1, 1}}, l2);

    auto prog = optimize_onnx("deconv_output_shape_test.onnx");
    EXPECT(p == prog);
}

TEST_CASE(deconv_output_padding_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1 = p.add_parameter("w", {migraphx::shape::float_type, {1, 2, 3, 3}});
    auto l2 = p.add_instruction(migraphx::op::deconvolution{{0, 0}, {3, 2}}, l0, l1);
    p.add_instruction(migraphx::op::pad{{0, 0, 0, 0, 0, 0, 1, 1}}, l2);

    auto prog = optimize_onnx("deconv_output_padding_test.onnx");
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
589
TEST_CASE(dropout_test)
Shucai Xiao's avatar
Shucai Xiao committed
590
591
{
    migraphx::program p;
Khalique's avatar
Khalique committed
592
593
    auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}});
    p.add_instruction(migraphx::op::identity{}, input);
Shucai Xiao's avatar
Shucai Xiao committed
594

Shucai Xiao's avatar
Shucai Xiao committed
595
    auto prog = optimize_onnx("dropout_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
596
597
598
599

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
600
601
602
603
604
605
TEST_CASE(elu_test)
{
    migraphx::program p;
    auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    p.add_instruction(migraphx::op::elu{0.01}, input);

Shucai Xiao's avatar
Shucai Xiao committed
606
    auto prog = optimize_onnx("elu_test.onnx");
Khalique's avatar
Khalique committed
607
608
609
610

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
611
TEST_CASE(erf_test)
612
613
{
    migraphx::program p;
Khalique's avatar
Khalique committed
614
615
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
    p.add_instruction(migraphx::op::erf{}, input);
Khalique's avatar
Khalique committed
616

Shucai Xiao's avatar
Shucai Xiao committed
617
    auto prog = optimize_onnx("erf_test.onnx");
Khalique's avatar
Khalique committed
618
619
620
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
621
TEST_CASE(exp_test)
622
623
624
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
Khalique's avatar
Khalique committed
625
    p.add_instruction(migraphx::op::exp{}, input);
Khalique's avatar
Khalique committed
626

Shucai Xiao's avatar
Shucai Xiao committed
627
    auto prog = optimize_onnx("exp_test.onnx");
Khalique's avatar
Khalique committed
628
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
629
630
}

Khalique's avatar
Khalique committed
631
TEST_CASE(expand_test)
632
633
{
    migraphx::program p;
Khalique's avatar
Khalique committed
634
635
636
637
638
    migraphx::shape s(migraphx::shape::float_type, {3, 1, 1});
    auto param = p.add_parameter("x", s);
    migraphx::shape ss(migraphx::shape::int32_type, {4});
    p.add_literal(migraphx::literal(ss, {2, 3, 4, 5}));
    p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, param);
Khalique's avatar
Khalique committed
639

Shucai Xiao's avatar
Shucai Xiao committed
640
    auto prog = optimize_onnx("expand_test.onnx");
Khalique's avatar
Khalique committed
641
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
642
643
}

Khalique's avatar
Khalique committed
644
TEST_CASE(flatten_test)
645
646
647
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
Khalique's avatar
Khalique committed
648
649
    p.add_instruction(migraphx::op::flatten{2}, l0);
    p.add_instruction(migraphx::op::flatten{1}, l0);
Shucai Xiao's avatar
Shucai Xiao committed
650
    auto prog = optimize_onnx("flatten_test.onnx");
651
652
653
654

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
655
656
657
658
659
660
TEST_CASE(floor_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::floor{}, input);

Shucai Xiao's avatar
Shucai Xiao committed
661
    auto prog = optimize_onnx("floor_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
662
663
664
665

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
666
TEST_CASE(gather_test)
667
668
{
    migraphx::program p;
Khalique's avatar
Khalique committed
669
670
671
672
    auto l0  = p.add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto l1  = p.add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 3}});
    int axis = 1;
    p.add_instruction(migraphx::op::gather{axis}, l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
673
    auto prog = optimize_onnx("gather_test.onnx");
674
675
676
677

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
678
TEST_CASE(gemm_test)
679
680
{
    migraphx::program p;
681
682
683
    auto l0    = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 7}});
    auto l1    = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {11, 5}});
    auto l2    = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type});
Khalique's avatar
Khalique committed
684
685
    auto t0    = p.add_instruction(migraphx::op::transpose{{1, 0}}, l0);
    auto t1    = p.add_instruction(migraphx::op::transpose{{1, 0}}, l1);
686
    auto bl2   = p.add_instruction(migraphx::op::multibroadcast{{7, 11}}, l2);
Khalique's avatar
Khalique committed
687
688
    auto alpha = 2.f;
    auto beta  = 2.0f;
689
    p.add_instruction(migraphx::op::dot{alpha, beta}, t0, t1, bl2);
Shucai Xiao's avatar
Shucai Xiao committed
690
    auto prog = optimize_onnx("gemm_test.onnx");
691
692
693
694

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
695
TEST_CASE(gemm_ex_test)
696
697
{
    migraphx::program p;
Khalique's avatar
Khalique committed
698
699
700
701
702
703
704
    auto l0    = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 6}});
    auto l1    = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 7}});
    auto l2    = p.add_parameter("3", migraphx::shape{migraphx::shape::float_type, {1, 1, 6, 7}});
    auto t0    = p.add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l0);
    auto alpha = 0.5f;
    auto beta  = 0.8f;
    p.add_instruction(migraphx::op::dot{alpha, beta}, t0, l1, l2);
Shucai Xiao's avatar
Shucai Xiao committed
705
    auto prog = optimize_onnx("gemm_ex_test.onnx");
706
707
708
709

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
710
TEST_CASE(gemm_ex_brcst_test)
711
712
{
    migraphx::program p;
Khalique's avatar
Khalique committed
713
714
715
716
717
718
719
720
721
    auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 6}});
    auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 7}});
    auto l2 = p.add_parameter("3", migraphx::shape{migraphx::shape::float_type, {1, 1, 6, 1}});
    auto t0 = p.add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l0);
    std::vector<std::size_t> out_lens{1, 1, 6, 7};
    auto t2    = p.add_instruction(migraphx::op::multibroadcast{out_lens}, l2);
    auto alpha = 0.5f;
    auto beta  = 0.8f;
    p.add_instruction(migraphx::op::dot{alpha, beta}, t0, l1, t2);
Shucai Xiao's avatar
Shucai Xiao committed
722
    auto prog = optimize_onnx("gemm_ex_brcst_test.onnx");
723
724
725
726

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
727
TEST_CASE(globalavgpool_test)
728
729
{
    migraphx::program p;
Khalique's avatar
Khalique committed
730
731
732
733
734
735
    auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    auto op    = migraphx::op::pooling{"average"};
    auto lens  = input->get_shape().lens();
    op.lengths = {lens[2], lens[3]};
    p.add_instruction(op, input);

Shucai Xiao's avatar
Shucai Xiao committed
736
    auto prog = optimize_onnx("globalavgpool_test.onnx");
737
738
739
740

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
741
TEST_CASE(globalmaxpool_test)
Khalique's avatar
Khalique committed
742
743
{
    migraphx::program p;
Khalique's avatar
Khalique committed
744
745
746
747
748
749
    auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    auto op    = migraphx::op::pooling{"max"};
    auto lens  = input->get_shape().lens();
    op.lengths = {lens[2], lens[3]};
    p.add_instruction(op, input);

Shucai Xiao's avatar
Shucai Xiao committed
750
    auto prog = optimize_onnx("globalmaxpool_test.onnx");
Khalique's avatar
Khalique committed
751
752
753
754

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
755
TEST_CASE(group_conv_test)
756
757
{
    migraphx::program p;
Khalique's avatar
Khalique committed
758
759
760
761
762
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 4, 16, 16}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 1, 3, 3}});
    migraphx::op::convolution op;
    op.group = 4;
    p.add_instruction(op, l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
763
    auto prog = optimize_onnx("group_conv_test.onnx");
764
765
766
767

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
768
TEST_CASE(imagescaler_test)
769
770
{
    migraphx::program p;
Khalique's avatar
Khalique committed
771
772
773
774
775
776
777
778
779
780
    migraphx::shape s{migraphx::shape::float_type, {1, 3, 16, 16}};
    auto l0        = p.add_parameter("0", s);
    auto scale_val = p.add_literal(0.5f);
    auto bias_vals = p.add_literal(
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
    auto scaled_tensor = p.add_instruction(migraphx::op::scalar{s.lens()}, scale_val);
    auto img_scaled    = p.add_instruction(migraphx::op::mul{}, l0, scaled_tensor);
    auto bias_bcast    = p.add_instruction(migraphx::op::broadcast{1, s.lens()}, bias_vals);
    p.add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);

Shucai Xiao's avatar
Shucai Xiao committed
781
    auto prog = optimize_onnx("imagescaler_test.onnx");
782
783
784
785

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
TEST_CASE(imagescaler_half_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::half_type, {1, 3, 16, 16}};
    auto l0 = p.add_parameter("0", s);
    auto scale_val =
        p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type}, {0.5f}});
    auto bias_vals = p.add_literal(
        migraphx::literal{migraphx::shape{migraphx::shape::half_type, {3}}, {0.01, 0.02, 0.03}});
    auto scaled_tensor = p.add_instruction(migraphx::op::scalar{s.lens()}, scale_val);
    auto img_scaled    = p.add_instruction(migraphx::op::mul{}, l0, scaled_tensor);
    auto bias_bcast    = p.add_instruction(migraphx::op::broadcast{1, s.lens()}, bias_vals);
    p.add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);

    auto prog = optimize_onnx("imagescaler_half_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
805
TEST_CASE(implicit_add_bcast_test)
806
807
{
    migraphx::program p;
Khalique's avatar
Khalique committed
808
809
810
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4, 1}});
    auto l3 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
811
    p.add_instruction(migraphx::op::add{}, l0, l3);
Khalique's avatar
Khalique committed
812

Shucai Xiao's avatar
Shucai Xiao committed
813
    auto prog = optimize_onnx("implicit_add_bcast_test.onnx");
814
815
816
817

    EXPECT(p == prog);
}

818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
TEST_CASE(implicit_add_bcast_user_input_shape_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 5, 1}});
    auto l3 = p.add_instruction(migraphx::op::multibroadcast{{3, 4, 5, 6}}, l1);
    auto r  = p.add_instruction(migraphx::op::add{}, l0, l3);
    p.add_return({r});

    migraphx::onnx_options options;
    options.map_input_dims["0"] = {3, 4, 5, 6};
    options.map_input_dims["1"] = {4, 5, 1};
    auto prog                   = migraphx::parse_onnx("implicit_add_bcast_test.onnx", options);

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
835
TEST_CASE(implicit_pow_bcast_test)
836
837
{
    migraphx::program p;
Khalique's avatar
Khalique committed
838
839
840
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4, 1}});
    auto l3 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
841
    p.add_instruction(migraphx::op::pow{}, l0, l3);
Khalique's avatar
Khalique committed
842

Shucai Xiao's avatar
Shucai Xiao committed
843
    auto prog = optimize_onnx("implicit_pow_bcast_test.onnx");
844
845
846
847

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
848
TEST_CASE(implicit_sub_bcast_test)
849
850
851
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
Khalique's avatar
Khalique committed
852
853
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 5}});
    auto l3 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
854
    p.add_instruction(migraphx::op::sub{}, l0, l3);
Khalique's avatar
Khalique committed
855

Shucai Xiao's avatar
Shucai Xiao committed
856
    auto prog = optimize_onnx("implicit_sub_bcast_test.onnx");
857
858
859
860

    EXPECT(p == prog);
}

861
862
863
864
865
866
867
868
TEST_CASE(initializer_not_an_input)
{
    migraphx::program p;
    std::vector<float> w = {1, 2, 3, 4, 5, 6, 7, 8};
    auto l1 = p.add_literal(migraphx::literal({migraphx::shape::float_type, {2, 4}}, w));
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {5, 2}});
    p.add_instruction(migraphx::op::dot{}, l0, l1);

Shucai Xiao's avatar
Shucai Xiao committed
869
    auto prog = optimize_onnx("initializer_not_an_input.onnx");
kahmed10's avatar
kahmed10 committed
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901

    EXPECT(p == prog);
}

TEST_CASE(instance_norm_test)
{
    std::vector<size_t> dims{1, 2, 3, 3};
    migraphx::shape s1{migraphx::shape::float_type, dims};
    migraphx::shape s2{migraphx::shape::float_type, {2}};

    migraphx::program p;
    auto x     = p.add_parameter("0", s1);
    auto scale = p.add_parameter("1", s2);
    auto bias  = p.add_parameter("2", s2);

    auto mean            = p.add_instruction(migraphx::op::reduce_mean{{2, 3}}, x);
    auto mean_bcast      = p.add_instruction(migraphx::op::multibroadcast{dims}, mean);
    auto l0              = p.add_instruction(migraphx::op::sqdiff{}, x, mean_bcast);
    auto variance        = p.add_instruction(migraphx::op::reduce_mean{{2, 3}}, l0);
    auto l1              = p.add_instruction(migraphx::op::sub{}, x, mean_bcast);
    auto epsilon_literal = p.add_literal(1e-5f);
    auto epsilon_bcast   = p.add_instruction(migraphx::op::multibroadcast{dims}, epsilon_literal);
    auto variance_bcast  = p.add_instruction(migraphx::op::multibroadcast{dims}, variance);
    auto l2              = p.add_instruction(migraphx::op::add{}, variance_bcast, epsilon_bcast);
    auto l3              = p.add_instruction(migraphx::op::rsqrt{}, l2);
    auto l4              = p.add_instruction(migraphx::op::mul{}, l1, l3);
    auto scale_bcast     = p.add_instruction(migraphx::op::broadcast{1, dims}, scale);
    auto bias_bcast      = p.add_instruction(migraphx::op::broadcast{1, dims}, bias);
    auto l5              = p.add_instruction(migraphx::op::mul{}, l4, scale_bcast);
    p.add_instruction(migraphx::op::add{}, l5, bias_bcast);

    auto prog = optimize_onnx("instance_norm_test.onnx");
902
903
904
905

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
906
TEST_CASE(leaky_relu_test)
907
908
{
    migraphx::program p;
Khalique's avatar
Khalique committed
909
910
911
912
    float alpha = 0.01f;
    auto l0     = p.add_parameter("0", {migraphx::shape::float_type, {3}});
    p.add_instruction(migraphx::op::leaky_relu{alpha}, l0);

Shucai Xiao's avatar
Shucai Xiao committed
913
    auto prog = optimize_onnx("leaky_relu_test.onnx");
914
915
916
917

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
918
TEST_CASE(log_test)
919
920
{
    migraphx::program p;
Khalique's avatar
Khalique committed
921
922
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::log{}, input);
923

Shucai Xiao's avatar
Shucai Xiao committed
924
    auto prog = optimize_onnx("log_test.onnx");
925
926
927
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
928
TEST_CASE(logsoftmax_test)
929
930
{
    migraphx::program p;
Khalique's avatar
Khalique committed
931
932
933
    auto l0  = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    int axis = 1;
    p.add_instruction(migraphx::op::logsoftmax{axis}, l0);
Shucai Xiao's avatar
Shucai Xiao committed
934
    auto prog = optimize_onnx("logsoftmax_test.onnx");
935
936
937
938

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
939
TEST_CASE(lrn_test)
940
941
{
    migraphx::program p;
Khalique's avatar
Khalique committed
942
943
944
945
946
947
948
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 28, 24, 24}});
    migraphx::op::lrn op;
    op.size  = 5;
    op.alpha = 0.0001;
    op.beta  = 0.75;
    op.bias  = 1.0;
    p.add_instruction(op, l0);
Shucai Xiao's avatar
Shucai Xiao committed
949
    auto prog = optimize_onnx("lrn_test.onnx");
950
951
952
953

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
954
TEST_CASE(matmul_bmbm_test)
955
956
{
    migraphx::program p;
Khalique's avatar
Khalique committed
957
958
959
960
961
962
    auto l0  = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 6, 7}});
    auto l1  = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {5, 2, 1, 7, 8}});
    auto bl0 = p.add_instruction(migraphx::op::multibroadcast{{5, 2, 3, 6, 7}}, l0);
    auto bl1 = p.add_instruction(migraphx::op::multibroadcast{{5, 2, 3, 7, 8}}, l1);
    p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, bl0, bl1);

Shucai Xiao's avatar
Shucai Xiao committed
963
    auto prog = optimize_onnx("matmul_bmbm_test.onnx");
964
965
966
967

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
968
TEST_CASE(matmul_bmv_test)
969
{
Khalique's avatar
Khalique committed
970
971
972
973
974
975
976
    migraphx::program p;
    auto l0   = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 6, 7}});
    auto l1   = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7}});
    auto sl1  = p.add_instruction(migraphx::op::unsqueeze{{1}}, l1);
    auto bsl1 = p.add_instruction(migraphx::op::multibroadcast{{3, 7, 1}}, sl1);
    auto res  = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, l0, bsl1);
    p.add_instruction(migraphx::op::squeeze{{2}}, res);
977

Shucai Xiao's avatar
Shucai Xiao committed
978
    auto prog = optimize_onnx("matmul_bmv_test.onnx");
979

Khalique's avatar
Khalique committed
980
    EXPECT(p == prog);
981
982
}

Khalique's avatar
Khalique committed
983
TEST_CASE(matmul_mv_test)
984
985
{
    migraphx::program p;
Khalique's avatar
Khalique committed
986
987
988
989
990
991
    auto l0  = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {6, 7}});
    auto l1  = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7}});
    auto sl1 = p.add_instruction(migraphx::op::unsqueeze{{1}}, l1);
    auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, l0, sl1);
    p.add_instruction(migraphx::op::squeeze{{1}}, res);

Shucai Xiao's avatar
Shucai Xiao committed
992
    auto prog = optimize_onnx("matmul_mv_test.onnx");
993
994
995
996

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
997
TEST_CASE(matmul_vbm_test)
998
999
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1000
1001
1002
1003
    auto l0   = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}});
    auto l1   = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {5, 7, 8}});
    auto sl0  = p.add_instruction(migraphx::op::unsqueeze{{0}}, l0);
    auto bsl0 = p.add_instruction(migraphx::op::multibroadcast{{5, 1, 7}}, sl0);
1004
    auto res  = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, bsl0, l1);
Khalique's avatar
Khalique committed
1005
1006
    p.add_instruction(migraphx::op::squeeze{{1}}, res);

Shucai Xiao's avatar
Shucai Xiao committed
1007
    auto prog = optimize_onnx("matmul_vbm_test.onnx");
1008
1009
1010
1011

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1012
TEST_CASE(matmul_vm_test)
1013
1014
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1015
1016
1017
1018
1019
1020
    auto l0  = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}});
    auto l1  = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7, 8}});
    auto sl0 = p.add_instruction(migraphx::op::unsqueeze{{0}}, l0);
    auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, sl0, l1);
    p.add_instruction(migraphx::op::squeeze{{0}}, res);

Shucai Xiao's avatar
Shucai Xiao committed
1021
    auto prog = optimize_onnx("matmul_vm_test.onnx");
1022
1023
1024
1025

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1026
TEST_CASE(matmul_vv_test)
1027
1028
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1029
1030
    auto l0  = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}});
    auto l1  = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7}});
1031
1032
1033
1034
1035
1036
    auto sl0 = p.add_instruction(migraphx::op::unsqueeze{{0}}, l0);
    auto sl1 = p.add_instruction(migraphx::op::unsqueeze{{1}}, l1);
    auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, sl0, sl1);
    auto sr0 = p.add_instruction(migraphx::op::squeeze{{0}}, res);
    p.add_instruction(migraphx::op::squeeze{{0}}, sr0);

Shucai Xiao's avatar
Shucai Xiao committed
1037
    auto prog = optimize_onnx("matmul_vv_test.onnx");
1038
1039
1040
1041

    EXPECT(p == prog);
}

1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
TEST_CASE(matmulinteger_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::int8_type, {3, 6, 16}});
    auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::int8_type, {3, 16, 8}});
    p.add_instruction(migraphx::op::quant_dot{1, 0}, l0, l1);

    auto prog = optimize_onnx("matmulinteger_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1054
TEST_CASE(max_test)
1055
1056
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1057
1058
1059
1060
1061
    auto input0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
    auto l0     = p.add_instruction(migraphx::op::max{}, input0, input1);
    p.add_instruction(migraphx::op::max{}, l0, input2);
1062

Shucai Xiao's avatar
Shucai Xiao committed
1063
    optimize_onnx("max_test.onnx");
Khalique's avatar
Khalique committed
1064
}
1065

1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
TEST_CASE(maxpool_notset_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
    float val                 = std::numeric_limits<float>::lowest();
    auto ins_pad              = p.add_instruction(migraphx::op::pad{pads, val}, input);
    p.add_instruction(migraphx::op::pooling{"max", {0, 0}, {2, 2}, {6, 6}}, ins_pad);

    auto prog = optimize_onnx("maxpool_notset_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(maxpool_same_upper_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
    float val                 = std::numeric_limits<float>::lowest();
    auto ins_pad              = p.add_instruction(migraphx::op::pad{pads, val}, input);
    p.add_instruction(
        migraphx::op::pooling{"max", {0, 0}, {1, 1}, {2, 2}, migraphx::op::padding_mode_t::same},
        ins_pad);

    auto prog = optimize_onnx("maxpool_same_upper_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1096
1097
1098
1099
1100
1101
1102
1103
1104
TEST_CASE(min_test)
{
    migraphx::program p;
    auto input0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
    auto l0     = p.add_instruction(migraphx::op::min{}, input0, input1);
    p.add_instruction(migraphx::op::min{}, l0, input2);

Shucai Xiao's avatar
Shucai Xiao committed
1105
    optimize_onnx("min_test.onnx");
1106
1107
}

Khalique's avatar
Khalique committed
1108
TEST_CASE(no_pad_test)
1109
1110
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1111
1112
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
    p.add_instruction(migraphx::op::identity{}, l0);
Shucai Xiao's avatar
Shucai Xiao committed
1113
    auto prog = optimize_onnx("no_pad_test.onnx");
1114

Khalique's avatar
Khalique committed
1115
1116
1117
    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1118
1119
1120
TEST_CASE(onehot_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
    migraphx::shape s_ind{migraphx::shape::int32_type, {5, 2}};
    migraphx::shape s_val{migraphx::shape::half_type, {2}};
    p.add_literal(3);
    auto l_ind = p.add_parameter("indices", s_ind);
    auto l_val = p.add_parameter("values", s_val);
    migraphx::shape s_dep{migraphx::shape::half_type, {3, 3}};
    std::vector<float> data_dep{1, 0, 0, 0, 1, 0, 0, 0, 1};
    auto l_dep      = p.add_literal(migraphx::literal(s_dep, data_dep));
    auto gather_out = p.add_instruction(migraphx::op::gather{0}, l_dep, l_ind);
    auto tr_out     = p.add_instruction(migraphx::op::transpose{{2, 0, 1}}, gather_out);
    auto off_val    = p.add_instruction(migraphx::op::slice{{0}, {0}, {1}}, l_val);
    auto on_val     = p.add_instruction(migraphx::op::slice{{0}, {1}, {2}}, l_val);
    auto diff       = p.add_instruction(migraphx::op::sub{}, on_val, off_val);
    auto mb_off_val = p.add_instruction(migraphx::op::multibroadcast{{3, 5, 2}}, off_val);
    auto mb_diff    = p.add_instruction(migraphx::op::multibroadcast{{3, 5, 2}}, diff);
    auto mul        = p.add_instruction(migraphx::op::mul{}, tr_out, mb_diff);
    auto r          = p.add_instruction(migraphx::op::add{}, mul, mb_off_val);
    p.add_return({r});

    auto prog = migraphx::parse_onnx("onehot_test.onnx");
kahmed10's avatar
kahmed10 committed
1141
1142
1143
1144

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1145
1146
1147
1148
1149
TEST_CASE(pad_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
    p.add_instruction(migraphx::op::pad{{1, 1, 1, 1}}, l0);
Shucai Xiao's avatar
Shucai Xiao committed
1150
    auto prog = optimize_onnx("pad_test.onnx");
1151
1152
1153
1154

    EXPECT(p == prog);
}

1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
TEST_CASE(pad_3arg_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
    p.add_literal({migraphx::shape{migraphx::shape::float_type}, {1.0f}});
    p.add_literal({migraphx::shape{migraphx::shape::int32_type, {4}}, {1, 1, 2, 2}});
    auto r = p.add_instruction(migraphx::op::pad{{1, 1, 2, 2}, 1.0f}, l0);
    p.add_return({r});

    auto prog = migraphx::parse_onnx("pad_3arg_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1169
TEST_CASE(pow_test)
1170
1171
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1172
1173
1174
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    p.add_instruction(migraphx::op::pow{}, l0, l1);
1175

Shucai Xiao's avatar
Shucai Xiao committed
1176
    auto prog = optimize_onnx("pow_test.onnx");
1177
1178
1179
1180

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
TEST_CASE(prelu_brcst_test)
{
    migraphx::program p;
    auto l0  = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1  = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 5}});
    auto bl1 = p.add_instruction(migraphx::op::multibroadcast{l0->get_shape().lens()}, l1);
    auto ret = p.add_instruction(migraphx::op::prelu{}, l0, bl1);
    p.add_return({ret});

    auto prog = migraphx::parse_onnx("prelu_brcst_test.onnx");

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
TEST_CASE(recip_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3}});
    p.add_instruction(migraphx::op::recip{}, input);

    auto prog = optimize_onnx("recip_test.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
TEST_CASE(reducel1_test)
{
    migraphx::program p;
    auto l0     = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto abs_l0 = p.add_instruction(migraphx::op::abs{}, l0);
    auto sum_l0 = p.add_instruction(migraphx::op::reduce_sum{{-2}}, abs_l0);
    p.add_instruction(migraphx::op::squeeze{{-2}}, sum_l0);
    auto prog = optimize_onnx("reducel1_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(reducel2_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto square_l0 = p.add_instruction(migraphx::op::mul{}, l0, l0);
    auto sum_l0    = p.add_instruction(migraphx::op::reduce_sum{{-1}}, square_l0);
    auto squ_l0    = p.add_instruction(migraphx::op::squeeze{{-1}}, sum_l0);
    p.add_instruction(migraphx::op::sqrt{}, squ_l0);
    auto prog = optimize_onnx("reducel2_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(reduce_log_sum_test)
{
    migraphx::program p;
    auto l0     = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto sum_l0 = p.add_instruction(migraphx::op::reduce_sum{{-3}}, l0);
    p.add_instruction(migraphx::op::log{}, sum_l0);
    auto prog = optimize_onnx("reduce_log_sum_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(reduce_log_sum_exp_test)
{
    migraphx::program p;
    auto l0     = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto exp_l0 = p.add_instruction(migraphx::op::exp{}, l0);
    auto sum_l0 = p.add_instruction(migraphx::op::reduce_sum{{-4}}, exp_l0);
    p.add_instruction(migraphx::op::log{}, sum_l0);
    auto prog = optimize_onnx("reduce_log_sum_exp_test.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1254
1255
1256
1257
1258
TEST_CASE(reducemax_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    p.add_instruction(migraphx::op::reduce_max{{2}}, l0);
Shucai Xiao's avatar
Shucai Xiao committed
1259
    auto prog = optimize_onnx("reducemax_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1260
1261
1262
1263

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1264
TEST_CASE(reducemean_test)
1265
1266
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1267
1268
1269
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto l1 = p.add_instruction(migraphx::op::reduce_mean{{2, 3}}, l0);
    p.add_instruction(migraphx::op::squeeze{{2, 3}}, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1270
    auto prog = optimize_onnx("reducemean_test.onnx");
1271
1272
1273
1274

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1275
TEST_CASE(reducemean_keepdims_test)
1276
1277
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1278
1279
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    p.add_instruction(migraphx::op::reduce_mean{{2}}, l0);
Shucai Xiao's avatar
Shucai Xiao committed
1280
    auto prog = optimize_onnx("reducemean_keepdims_test.onnx");
1281
1282
1283
1284

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1285
1286
1287
1288
1289
1290
TEST_CASE(reducemin_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto l1 = p.add_instruction(migraphx::op::reduce_min{{2, 3}}, l0);
    p.add_instruction(migraphx::op::squeeze{{2, 3}}, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1291
    auto prog = optimize_onnx("reducemin_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1292
1293
1294
1295

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
TEST_CASE(reduceprod_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    p.add_instruction(migraphx::op::reduce_prod{{2}}, l0);
    auto prog = optimize_onnx("reduceprod_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1306
TEST_CASE(reducesum_test)
Khalique's avatar
Khalique committed
1307
1308
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1309
1310
1311
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto l1 = p.add_instruction(migraphx::op::reduce_sum{{2}}, l0);
    p.add_instruction(migraphx::op::squeeze{{2}}, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1312
    auto prog = optimize_onnx("reducesum_test.onnx");
1313
1314

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

Khalique's avatar
Khalique committed
1317
TEST_CASE(reducesum_multiaxis_test)
Khalique's avatar
Khalique committed
1318
1319
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1320
1321
1322
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto l1 = p.add_instruction(migraphx::op::reduce_sum{{2, 3}}, l0);
    p.add_instruction(migraphx::op::squeeze{{2, 3}}, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1323
    auto prog = optimize_onnx("reducesum_multiaxis_test.onnx");
1324
1325

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

Khalique's avatar
Khalique committed
1328
TEST_CASE(reducesum_keepdims_test)
Khalique's avatar
Khalique committed
1329
1330
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1331
1332
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    p.add_instruction(migraphx::op::reduce_sum{{2, 3}}, l0);
Shucai Xiao's avatar
Shucai Xiao committed
1333
    auto prog = optimize_onnx("reducesum_keepdims_test.onnx");
1334
1335
1336
1337

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
TEST_CASE(reducesum_square_test)
{
    migraphx::program p;
    auto l0     = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto squ_l0 = p.add_instruction(migraphx::op::mul{}, l0, l0);
    auto sum_l0 = p.add_instruction(migraphx::op::reduce_sum{{-2}}, squ_l0);
    p.add_instruction(migraphx::op::squeeze{{-2}}, sum_l0);
    auto prog = optimize_onnx("reducesum_square_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1350
TEST_CASE(reshape_test)
1351
{
Khalique's avatar
Khalique committed
1352
    migraphx::program p;
Khalique's avatar
Khalique committed
1353
1354
1355
1356
    migraphx::op::reshape op;
    std::vector<int64_t> reshape_dims{3, 8};
    p.add_literal(
        migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, reshape_dims});
1357
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {4, 2, 3}});
Khalique's avatar
Khalique committed
1358
1359
1360
    op.dims = reshape_dims;
    p.add_instruction(op, l0);
    p.add_instruction(op, l0);
Shucai Xiao's avatar
Shucai Xiao committed
1361
    auto prog = optimize_onnx("reshape_test.onnx");
1362
1363

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

Khalique's avatar
Khalique committed
1366
TEST_CASE(reshape_non_standard_test)
1367
1368
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1369
1370
1371
1372
1373
1374
1375
    migraphx::op::reshape op;
    std::vector<int64_t> reshape_dims{4, 3, 2};
    migraphx::shape s{migraphx::shape::float_type, {2, 3, 4}};
    auto x      = p.add_parameter("x", s);
    auto tran_x = p.add_instruction(migraphx::op::transpose{{0, 2, 1}}, x);
    auto cont_x = p.add_instruction(migraphx::op::contiguous{}, tran_x);
    p.add_instruction(migraphx::op::reshape{{4, 3, 2}}, cont_x);
Shucai Xiao's avatar
Shucai Xiao committed
1376
    auto prog = optimize_onnx("reshape_non_standard_test.onnx");
1377
1378
1379
1380

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1381
1382
1383
1384
1385
1386
TEST_CASE(round_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
    p.add_instruction(migraphx::op::round{}, input);

Shucai Xiao's avatar
Shucai Xiao committed
1387
    auto prog = optimize_onnx("round_test.onnx");
Khalique's avatar
Khalique committed
1388
1389
1390
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1391
TEST_CASE(shape_test)
1392
1393
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1394
1395
1396
1397
    migraphx::shape s{migraphx::shape::float_type, {3, 4, 5, 6}};
    auto l0 = p.add_parameter("x", s);
    migraphx::shape s_shape{migraphx::shape::int64_type, {4}};
    p.add_literal(s_shape, l0->get_shape().lens());
Shucai Xiao's avatar
Shucai Xiao committed
1398
    auto prog = optimize_onnx("shape_test.onnx");
1399
1400
1401
1402

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1403
TEST_CASE(shape_gather_test)
1404
1405
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1406
    auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {7, 3, 10}});
1407
1408
    migraphx::shape const_shape{migraphx::shape::int32_type, {1}};
    auto l2 = p.add_literal(migraphx::literal{const_shape, {1}});
Khalique's avatar
Khalique committed
1409
1410
1411
1412
    auto l1 =
        p.add_literal(migraphx::shape{migraphx::shape::int64_type, {3}}, l0->get_shape().lens());
    int axis = 0;
    p.add_instruction(migraphx::op::gather{axis}, l1, l2);
Shucai Xiao's avatar
Shucai Xiao committed
1413
    auto prog = optimize_onnx("shape_gather_test.onnx");
1414
1415
1416
1417

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1418
TEST_CASE(sign_test)
Khalique's avatar
Khalique committed
1419
1420
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1421
1422
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
    p.add_instruction(migraphx::op::sign{}, input);
Khalique's avatar
Khalique committed
1423

Shucai Xiao's avatar
Shucai Xiao committed
1424
    auto prog = optimize_onnx("sign_test.onnx");
Khalique's avatar
Khalique committed
1425
1426
1427
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1428
TEST_CASE(sin_test)
1429
1430
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1431
1432
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::sin{}, input);
1433

Shucai Xiao's avatar
Shucai Xiao committed
1434
    auto prog = optimize_onnx("sin_test.onnx");
1435
1436
1437
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1438
TEST_CASE(sinh_test)
1439
1440
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1441
1442
1443
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::sinh{}, input);

Shucai Xiao's avatar
Shucai Xiao committed
1444
    auto prog = optimize_onnx("sinh_test.onnx");
1445
1446
1447
1448

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
TEST_CASE(slice_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 2}});
    p.add_instruction(migraphx::op::slice{{0, 1}, {1, 0}, {2, 2}}, l0);
    auto prog = optimize_onnx("slice_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(slice_3arg_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 5}});
    p.add_literal({{migraphx::shape::int32_type, {2}}, {0, 0}});
    p.add_literal({{migraphx::shape::int32_type, {2}}, {2, 5}});
    auto ret = p.add_instruction(migraphx::op::slice{{0, 1}, {0, 0}, {2, 5}}, l0);
    p.add_return({ret});

    auto prog = migraphx::parse_onnx("slice_3arg_test.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1473
1474
1475
1476
1477
TEST_CASE(slice_5arg_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 5}});
    p.add_literal({{migraphx::shape::int32_type, {2}}, {1, 1}});
1478
1479
1480
    p.add_literal({{migraphx::shape::int32_type, {2}}, {-1, -2}});
    p.add_literal({{migraphx::shape::int32_type, {2}}, {-1, -1}});
    p.add_literal({{migraphx::shape::int32_type, {2}}, {-5, -3}});
Shucai Xiao's avatar
Shucai Xiao committed
1481
1482
1483
1484
1485
1486
1487
1488
    auto ret = p.add_instruction(migraphx::op::slice{{-1, -2}, {-5, -3}, {-1, -1}}, l0);
    p.add_return({ret});

    auto prog = migraphx::parse_onnx("slice_5arg_test.onnx");

    EXPECT(p == prog);
}

1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
TEST_CASE(slice_max_end_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {10, 20}});
    p.add_instruction(migraphx::op::slice{{0, 1}, {1, 2}, {3000000000, -1}}, l0);
    auto prog = optimize_onnx("slice_max_end_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1499
TEST_CASE(softmax_test)
Shucai Xiao's avatar
Shucai Xiao committed
1500
1501
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1502
1503
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
    p.add_instruction(migraphx::op::softmax{1}, l0);
Shucai Xiao's avatar
Shucai Xiao committed
1504
    auto prog = optimize_onnx("softmax_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1505
1506
1507
1508

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
TEST_CASE(split_minus_axis_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
    auto r1    = p.add_instruction(migraphx::op::slice{{-1}, {0}, {5}}, input);
    auto r2    = p.add_instruction(migraphx::op::slice{{-1}, {5}, {10}}, input);
    auto r3    = p.add_instruction(migraphx::op::slice{{-1}, {10}, {15}}, input);
    p.add_return({r1, r2, r3});

    auto prog = migraphx::parse_onnx("split_minus_axis_test.onnx");

    EXPECT(p == prog);
}

1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
TEST_CASE(split_test)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
    auto r1    = p.add_instruction(migraphx::op::slice{{1}, {0}, {7}}, input);
    auto r2    = p.add_instruction(migraphx::op::slice{{1}, {7}, {11}}, input);
    auto r3    = p.add_instruction(migraphx::op::slice{{1}, {11}, {15}}, input);
    p.add_return({r1, r2, r3});

    auto prog = migraphx::parse_onnx("split_test.onnx");
    EXPECT(p == prog);
}

TEST_CASE(split_test_default)
{
    migraphx::program p;
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
    auto r1    = p.add_instruction(migraphx::op::slice{{0}, {0}, {5}}, input);
    auto r2    = p.add_instruction(migraphx::op::slice{{0}, {5}, {10}}, input);
    p.add_return({r1, r2});

    auto prog = migraphx::parse_onnx("split_test_default.onnx");
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1548
TEST_CASE(sqrt_test)
Shucai Xiao's avatar
Shucai Xiao committed
1549
1550
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1551
1552
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
    p.add_instruction(migraphx::op::sqrt{}, input);
Shucai Xiao's avatar
Shucai Xiao committed
1553

Shucai Xiao's avatar
Shucai Xiao committed
1554
    auto prog = optimize_onnx("sqrt_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1555
1556
1557
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1558
TEST_CASE(squeeze_unsqueeze_test)
Khalique's avatar
Khalique committed
1559
1560
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1561
1562
1563
1564
1565
1566
    std::vector<int64_t> squeeze_axes{0, 2, 3, 5};
    std::vector<int64_t> unsqueeze_axes{0, 1, 3, 5};
    auto l0 =
        p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 1, 1, 2, 1}});
    auto l1 = p.add_instruction(migraphx::op::squeeze{squeeze_axes}, l0);
    p.add_instruction(migraphx::op::unsqueeze{unsqueeze_axes}, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1567
    auto prog = optimize_onnx("squeeze_unsqueeze_test.onnx");
Khalique's avatar
Khalique committed
1568
1569
1570
1571

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1572
TEST_CASE(sub_bcast_test)
Shucai Xiao's avatar
Shucai Xiao committed
1573
1574
1575
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
Khalique's avatar
Khalique committed
1576
1577
1578
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}});
    auto l2 = p.add_instruction(migraphx::op::broadcast{1, l0->get_shape().lens()}, l1);
    p.add_instruction(migraphx::op::sub{}, l0, l2);
Shucai Xiao's avatar
Shucai Xiao committed
1579

Shucai Xiao's avatar
Shucai Xiao committed
1580
    auto prog = optimize_onnx("sub_bcast_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1581
1582
1583
1584

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1585
TEST_CASE(sub_scalar_test)
Shucai Xiao's avatar
Shucai Xiao committed
1586
1587
1588
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
1589
    auto l1 = p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::float_type}, {1}});
Khalique's avatar
Khalique committed
1590
    auto m1 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
1591
    p.add_instruction(migraphx::op::sub{}, l0, m1);
Shucai Xiao's avatar
Shucai Xiao committed
1592
    auto prog = optimize_onnx("sub_scalar_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1593
1594
1595
1596

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1597
TEST_CASE(sum_test)
1598
1599
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1600
1601
1602
1603
1604
    auto input0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
    auto l0     = p.add_instruction(migraphx::op::add{}, input0, input1);
    p.add_instruction(migraphx::op::add{}, l0, input2);
1605

Shucai Xiao's avatar
Shucai Xiao committed
1606
    auto prog = optimize_onnx("sum_test.onnx");
1607
1608
1609
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1610
TEST_CASE(tan_test)
1611
1612
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1613
1614
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
    p.add_instruction(migraphx::op::tan{}, input);
1615

Shucai Xiao's avatar
Shucai Xiao committed
1616
    auto prog = optimize_onnx("tan_test.onnx");
1617
1618
1619
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1620
TEST_CASE(tanh_test)
1621
1622
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1623
1624
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}});
    p.add_instruction(migraphx::op::tanh{}, input);
1625

Shucai Xiao's avatar
Shucai Xiao committed
1626
    auto prog = optimize_onnx("tanh_test.onnx");
1627
1628
1629
1630

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
TEST_CASE(tile_test)
{
    migraphx::program p;
    p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, {1, 2}});
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2, 2}});
    p.add_instruction(migraphx::op::concat{1}, input, input);

    auto prog = optimize_onnx("tile_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(tile_test_3x2)
{
    migraphx::program p;
    p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, {3, 2}});
    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2, 2}});
    auto l0    = p.add_instruction(migraphx::op::concat{0}, input, input);
    auto l1    = p.add_instruction(migraphx::op::concat{0}, l0, input);
    p.add_instruction(migraphx::op::concat{1}, l1, l1);

    auto prog = optimize_onnx("tile_test_3x2.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1657
TEST_CASE(transpose_test)
1658
1659
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1660
1661
1662
1663
    auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    std::vector<int64_t> perm{0, 3, 1, 2};
    p.add_instruction(migraphx::op::transpose{perm}, input);

Shucai Xiao's avatar
Shucai Xiao committed
1664
    auto prog = optimize_onnx("transpose_test.onnx");
1665
1666
1667
1668

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1669
TEST_CASE(transpose_gather_test)
1670
1671
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
    auto make_contiguous = [&p](migraphx::instruction_ref ins) {
        if(ins->get_shape().standard())
        {
            return ins;
        }

        return p.add_instruction(migraphx::op::contiguous{}, ins);
    };

    auto data = p.add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 5, 4, 6}});
    auto ind =
        p.add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 4, 3, 5}});
    auto tr_data = p.add_instruction(migraphx::op::transpose{{0, 2, 1, 3}}, data);
    auto tr_ind  = p.add_instruction(migraphx::op::transpose{{0, 2, 1, 3}}, ind);
    int axis     = 1;
    p.add_instruction(
        migraphx::op::gather{axis}, make_contiguous(tr_data), make_contiguous(tr_ind));

Shucai Xiao's avatar
Shucai Xiao committed
1690
    auto prog = optimize_onnx("transpose_gather_test.onnx");
1691
1692
1693
1694

    EXPECT(p == prog);
}

1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
TEST_CASE(undefined_test)
{
    migraphx::program p;
    p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1 = p.add_instruction(migraphx::op::undefined{});
    auto l2 = p.add_instruction(migraphx::op::identity{}, l1);
    p.add_return({l2});

    auto prog = migraphx::parse_onnx("undefined_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1708
TEST_CASE(unknown_test)
1709
1710
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1711
1712
1713
1714
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}});
    auto l2 = p.add_instruction(migraphx::op::unknown{"Unknown"}, l0, l1);
    p.add_instruction(migraphx::op::unknown{"Unknown"}, l2);
Shucai Xiao's avatar
Shucai Xiao committed
1715
    auto prog = optimize_onnx("unknown_test.onnx");
1716
1717
1718
1719

    EXPECT(p == prog);
}

1720
1721
1722
1723
1724
TEST_CASE(variable_batch_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);
Shucai Xiao's avatar
Shucai Xiao committed
1725
    auto prog = optimize_onnx("variable_batch_test.onnx");
1726
1727
1728
1729

    EXPECT(p == prog);
}

1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
TEST_CASE(variable_batch_user_input_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 16, 16}});
    auto r  = p.add_instruction(migraphx::op::identity{}, l0);
    p.add_return({r});

    migraphx::onnx_options options;
    options.default_dim_value = 2;

    auto prog = migraphx::parse_onnx("variable_batch_test.onnx", options);

    EXPECT(p == prog);
}

1745
1746
1747
1748
1749
1750
TEST_CASE(variable_batch_leq_zero_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    p.add_instruction(migraphx::op::add{}, l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1751
    auto prog = optimize_onnx("variable_batch_leq_zero_test.onnx");
1752
1753
1754
1755

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1756
int main(int argc, const char* argv[]) { test::run(argc, argv); }