onnx_test.cpp 106 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>
12
13
14
15
#include <migraphx/make_op.hpp>

#include <migraphx/serialize.hpp>

Scott Thornton's avatar
Scott Thornton committed
16
17
#include "test.hpp"

Shucai Xiao's avatar
Shucai Xiao committed
18
19
migraphx::program optimize_onnx(const std::string& name, bool eliminate_deadcode = false)
{
20
21
22
    migraphx::onnx_options options;
    options.skip_unknown_operators = true;
    auto prog                      = migraphx::parse_onnx(name, options);
23
    auto* mm                       = prog.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
24
    if(eliminate_deadcode)
25
        migraphx::run_passes(*mm, {migraphx::dead_code_elimination{}});
Shucai Xiao's avatar
Shucai Xiao committed
26
27

    // remove the last identity instruction
28
    auto last_ins = std::prev(mm->end());
29
    if(last_ins->name() == "@return")
Shucai Xiao's avatar
Shucai Xiao committed
30
    {
31
        mm->remove_instruction(last_ins);
Shucai Xiao's avatar
Shucai Xiao committed
32
33
34
35
36
    }

    return prog;
}

Khalique's avatar
Khalique committed
37
TEST_CASE(acos_test)
Scott Thornton's avatar
Scott Thornton committed
38
{
Paul's avatar
Paul committed
39
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
40
41
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
42
    mm->add_instruction(migraphx::make_op("acos"), input);
Scott Thornton's avatar
Scott Thornton committed
43

Shucai Xiao's avatar
Shucai Xiao committed
44
    auto prog = optimize_onnx("acos_test.onnx");
Scott Thornton's avatar
Scott Thornton committed
45
46
47
48

    EXPECT(p == prog);
}

49
50
51
TEST_CASE(acosh_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
52
53
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
54
    mm->add_instruction(migraphx::make_op("acosh"), input);
55
56
57
58
59
60

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
61
TEST_CASE(add_bcast_test)
62
{
Paul's avatar
Paul committed
63
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
64
65
66
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}});
67
68
69
    auto l2  = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", 1}, {"dims", l0->get_shape().lens()}}), l1);
    mm->add_instruction(migraphx::make_op("add"), l0, l2);
Paul's avatar
Paul committed
70

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

73
74
75
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
76
TEST_CASE(add_fp16_test)
Scott Thornton's avatar
Scott Thornton committed
77
{
Paul's avatar
Paul committed
78
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
79
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
80
    auto l0 =
Shucai Xiao's avatar
Shucai Xiao committed
81
        mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type, {1}}, {1.5}});
Khalique's avatar
Khalique committed
82
    auto l1 =
Shucai Xiao's avatar
Shucai Xiao committed
83
        mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type, {1}}, {2.5}});
84
    mm->add_instruction(migraphx::make_op("add"), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
85
    auto prog = optimize_onnx("add_fp16_test.onnx");
Scott Thornton's avatar
Scott Thornton committed
86
87
88
89

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
90
TEST_CASE(add_scalar_test)
91
{
Paul's avatar
Paul committed
92
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
93
94
95
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::uint8_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::uint8_type});
96
97
98
    auto m1  = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 4, 5}}}), l1);
    auto r = mm->add_instruction(migraphx::make_op("add"), l0, m1);
Shucai Xiao's avatar
Shucai Xiao committed
99
    mm->add_return({r});
100
    auto prog = migraphx::parse_onnx("add_scalar_test.onnx");
101
102
103
104

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
105
TEST_CASE(argmax_test)
Khalique's avatar
Khalique committed
106
{
Paul's avatar
Paul committed
107
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
108
109
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
110
111
    auto ins = mm->add_instruction(migraphx::make_op("argmax", {{"axis", 2}}), l0);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {2}}}), ins);
Shucai Xiao's avatar
Shucai Xiao committed
112
    auto prog = optimize_onnx("argmax_test.onnx");
Khalique's avatar
Khalique committed
113
114
115
116

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
117
TEST_CASE(argmin_test)
118
{
Paul's avatar
Paul committed
119
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
120
121
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
122
123
    auto ins = mm->add_instruction(migraphx::make_op("argmin", {{"axis", 3}}), l0);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {3}}}), ins);
Shucai Xiao's avatar
Shucai Xiao committed
124
    auto prog = optimize_onnx("argmin_test.onnx");
125
126
127
128

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
129
TEST_CASE(asin_test)
130
{
Paul's avatar
Paul committed
131
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
132
133
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
134
    mm->add_instruction(migraphx::make_op("asin"), input);
135

Shucai Xiao's avatar
Shucai Xiao committed
136
    auto prog = optimize_onnx("asin_test.onnx");
137
138
139
140

    EXPECT(p == prog);
}

141
142
143
TEST_CASE(asinh_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
144
145
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
146
    mm->add_instruction(migraphx::make_op("asinh"), input);
147
148
149
150
151
152

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
153
TEST_CASE(atan_test)
Khalique's avatar
Khalique committed
154
{
Paul's avatar
Paul committed
155
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
156
157
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
158
    mm->add_instruction(migraphx::make_op("atan"), input);
Khalique's avatar
Khalique committed
159

Shucai Xiao's avatar
Shucai Xiao committed
160
    auto prog = optimize_onnx("atan_test.onnx");
Khalique's avatar
Khalique committed
161
162
163
164

    EXPECT(p == prog);
}

165
166
167
TEST_CASE(atanh_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
168
169
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
170
    mm->add_instruction(migraphx::make_op("atanh"), input);
171
172
173
174
175
176

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

    EXPECT(p == prog);
}

177
178
179
TEST_CASE(averagepool_1d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
180
181
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 5}});
182
183
184
185
    mm->add_instruction(
        migraphx::make_op(
            "pooling", {{"mode", "average"}, {"padding", {0}}, {"stride", {1}}, {"lengths", {3}}}),
        l0);
186
187
188
189
190
191
192
193

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

TEST_CASE(averagepool_3d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
194
195
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 5, 5, 5}});
196
197
198
199
200
201
    mm->add_instruction(migraphx::make_op("pooling",
                                          {{"mode", "average"},
                                           {"padding", {0, 0, 0}},
                                           {"stride", {1, 1, 1}},
                                           {"lengths", {3, 3, 3}}}),
                        l0);
202
203
204
205
206

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

207
TEST_CASE(averagepool_notset_test)
208
209
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
210
211
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
212
213
214
215
216
217
218
    auto ins   = mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "average"}, {"padding", {2, 2}}, {"stride", {2, 2}}, {"lengths", {6, 6}}}),
        input);
    auto ret = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {2, 3}}, {"starts", {1, 1}}, {"ends", {2, 2}}}), ins);
Shucai Xiao's avatar
Shucai Xiao committed
219
    mm->add_return({ret});
220
221
222
223
224
225
    auto prog = migraphx::parse_onnx("averagepool_notset_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(averagepool_nt_cip_test)
226
227
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
228
229
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
230
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
231
232
233
234
235
236
    auto ins_pad = mm->add_instruction(migraphx::make_op("pad", {{"pads", pads}}), input);
    auto ret     = mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "average"}, {"padding", {0, 0}}, {"stride", {2, 2}}, {"lengths", {6, 6}}}),
        ins_pad);
Shucai Xiao's avatar
Shucai Xiao committed
237
    mm->add_return({ret});
238

239
    auto prog = migraphx::parse_onnx("averagepool_nt_cip_test.onnx");
240
241
242
243
    EXPECT(p == prog);
}

TEST_CASE(averagepool_same_lower_test)
244
245
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
246
247
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
248
249
250
251
252
253
254
    auto ins   = mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "average"}, {"padding", {1, 1}}, {"stride", {1, 1}}, {"lengths", {2, 2}}}),
        input);
    auto ret = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {2, 3}}, {"starts", {0, 0}}, {"ends", {5, 5}}}), ins);
Shucai Xiao's avatar
Shucai Xiao committed
255
    mm->add_return({ret});
256
257
258
259
260
261
    auto prog = migraphx::parse_onnx("averagepool_same_lower_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(averagepool_sl_cip_test)
262
263
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
264
265
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
266
    std::vector<int64_t> pads = {0, 0, 1, 1, 0, 0, 0, 0};
267
268
269
270
271
272
    auto ins_pad = mm->add_instruction(migraphx::make_op("pad", {{"pads", pads}}), input);
    auto ret     = mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "average"}, {"padding", {0, 0}}, {"stride", {1, 1}}, {"lengths", {2, 2}}}),
        ins_pad);
Shucai Xiao's avatar
Shucai Xiao committed
273
    mm->add_return({ret});
274
    auto prog = migraphx::parse_onnx("averagepool_sl_cip_test.onnx");
275
276
277
278
279
280
281

    EXPECT(p == prog);
}

TEST_CASE(averagepool_same_upper_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
282
283
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
284
285
286
287
288
289
290
    auto ins   = mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "average"}, {"padding", {1, 1}}, {"stride", {1, 1}}, {"lengths", {2, 2}}}),
        input);
    auto ret = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {2, 3}}, {"starts", {1, 1}}, {"ends", {6, 6}}}), ins);
Shucai Xiao's avatar
Shucai Xiao committed
291
    mm->add_return({ret});
292
    auto prog = migraphx::parse_onnx("averagepool_same_upper_test.onnx");
293
294
295
296

    EXPECT(p == prog);
}

297
298
299
TEST_CASE(batchnorm_1d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
300
301
302
303
304
305
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 5}});
    auto l1  = mm->add_parameter("1", {migraphx::shape::float_type, {3}});
    auto l2  = mm->add_parameter("2", {migraphx::shape::float_type, {3}});
    auto l3  = mm->add_parameter("3", {migraphx::shape::float_type, {3}});
    auto l4  = mm->add_parameter("4", {migraphx::shape::float_type, {3}});
306
    mm->add_instruction(migraphx::make_op("batch_norm_inference"), l0, l1, l2, l3, l4);
307
308
309
310
311
312
313
314

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

TEST_CASE(batchnorm_3d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
315
316
317
318
319
320
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 5, 5, 5}});
    auto l1  = mm->add_parameter("1", {migraphx::shape::float_type, {3}});
    auto l2  = mm->add_parameter("2", {migraphx::shape::float_type, {3}});
    auto l3  = mm->add_parameter("3", {migraphx::shape::float_type, {3}});
    auto l4  = mm->add_parameter("4", {migraphx::shape::float_type, {3}});
321
    mm->add_instruction(migraphx::make_op("batch_norm_inference"), l0, l1, l2, l3, l4);
322
323
324
325
326

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

Khalique's avatar
Khalique committed
327
TEST_CASE(cast_test)
Khalique's avatar
Khalique committed
328
{
Paul's avatar
Paul committed
329
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
330
331
    auto* mm = p.get_main_module();
    auto l   = mm->add_parameter("x", migraphx::shape{migraphx::shape::half_type, {10}});
332
333
334
335
    mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
        l);
Khalique's avatar
Khalique committed
336

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

Shucai Xiao's avatar
Shucai Xiao committed
341
342
343
TEST_CASE(ceil_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
344
345
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
346
    mm->add_instruction(migraphx::make_op("ceil"), input);
Shucai Xiao's avatar
Shucai Xiao committed
347

Shucai Xiao's avatar
Shucai Xiao committed
348
    auto prog = optimize_onnx("ceil_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
349
350
351
352

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
353
TEST_CASE(clip_test)
Khalique's avatar
Khalique committed
354
355
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
356
357
358
359
    auto* mm     = p.get_main_module();
    auto l0      = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    auto min_val = mm->add_literal(0.0f);
    auto max_val = mm->add_literal(6.0f);
360
361
362
363
364
    min_val =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {3}}}), min_val);
    max_val =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {3}}}), max_val);
    mm->add_instruction(migraphx::make_op("clip"), l0, min_val, max_val);
Shucai Xiao's avatar
Shucai Xiao committed
365
    auto prog = optimize_onnx("clip_test.onnx");
Khalique's avatar
Khalique committed
366

367
368
369
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
370
371
372
TEST_CASE(clip_test_op11_max_only)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
373
374
375
    auto* mm     = p.get_main_module();
    auto max_val = mm->add_literal(0.0f);
    auto l0      = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
376
377
378
379
    mm->add_instruction(migraphx::make_op("undefined"));
    max_val =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {3}}}), max_val);
    auto r = mm->add_instruction(migraphx::make_op("min"), l0, max_val);
Shucai Xiao's avatar
Shucai Xiao committed
380
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
381
382
383
384
385
386

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
387
388
389
TEST_CASE(clip_test_op11)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
390
391
392
393
    auto* mm     = p.get_main_module();
    auto min_val = mm->add_literal(0.0f);
    auto max_val = mm->add_literal(6.0f);
    auto l0      = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
394
395
396
397
398
    min_val =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {3}}}), min_val);
    max_val =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {3}}}), max_val);
    mm->add_instruction(migraphx::make_op("clip"), l0, min_val, max_val);
kahmed10's avatar
kahmed10 committed
399
400
401
402
403
404
405
406
    auto prog = optimize_onnx("clip_test_op11.onnx");

    EXPECT(p == prog);
}

TEST_CASE(clip_test_op11_min_only)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
407
408
409
    auto* mm     = p.get_main_module();
    auto min_val = mm->add_literal(0.0f);
    auto l0      = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
410
411
412
    min_val =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {3}}}), min_val);
    mm->add_instruction(migraphx::make_op("max"), l0, min_val);
kahmed10's avatar
kahmed10 committed
413
414
415
416
417
418
419
420
    auto prog = optimize_onnx("clip_test_op11_min_only.onnx");

    EXPECT(p == prog);
}

TEST_CASE(clip_test_op11_no_args)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
421
422
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
423
    mm->add_instruction(migraphx::make_op("identity"), l0);
kahmed10's avatar
kahmed10 committed
424
425
426
427
428
    auto prog = optimize_onnx("clip_test_op11_no_args.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
429
430
431
TEST_CASE(clip_test_op11_no_args1)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
432
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
433

Shucai Xiao's avatar
Shucai Xiao committed
434
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
435
436
    mm->add_instruction(migraphx::make_op("undefined"));
    auto r = mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
437
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
438
439
440
441
442
    auto prog = migraphx::parse_onnx("clip_test_op11_no_args1.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
443
TEST_CASE(concat_test)
Shucai Xiao's avatar
Shucai Xiao committed
444
445
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
446
447
448
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 4, 3}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7, 4, 3}});
449
    mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
450
    auto prog = optimize_onnx("concat_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
451
452
453
454

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
455
TEST_CASE(constant_test)
Shucai Xiao's avatar
Shucai Xiao committed
456
457
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
458
459
460
    auto* mm = p.get_main_module();
    mm->add_literal(
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0, 1, 2}});
Shucai Xiao's avatar
Shucai Xiao committed
461
    auto prog = optimize_onnx("constant_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
462
463
464
465

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
466
TEST_CASE(constant_fill_test)
Shucai Xiao's avatar
Shucai Xiao committed
467
{
Khalique's avatar
Khalique committed
468
469

    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
470
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
471
472
    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
    std::vector<float> value(s.elements(), 1.0);
Shucai Xiao's avatar
Shucai Xiao committed
473
    mm->add_literal(migraphx::literal{s, value});
Shucai Xiao's avatar
Shucai Xiao committed
474
    auto prog = optimize_onnx("constant_fill_test.onnx");
Khalique's avatar
Khalique committed
475
476
477
478
479
480
481

    EXPECT(p == prog);
}

TEST_CASE(constant_fill_input_as_shape_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
482
483
    auto* mm = p.get_main_module();
    auto l0  = mm->add_literal(migraphx::literal{{migraphx::shape::int32_type, {2}}, {2, 3}});
Khalique's avatar
Khalique committed
484
485
486
487
488
    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);
Shucai Xiao's avatar
Shucai Xiao committed
489
    mm->add_literal(migraphx::literal{s, value});
Shucai Xiao's avatar
Shucai Xiao committed
490
    auto prog = optimize_onnx("constant_fill_input_as_shape_test.onnx");
Khalique's avatar
Khalique committed
491
492

    EXPECT(p == prog);
Shucai Xiao's avatar
Shucai Xiao committed
493
494
}

Khalique's avatar
Khalique committed
495
TEST_CASE(constant_scalar_test)
496
497
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
498
499
    auto* mm = p.get_main_module();
    mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {1}}, {1}});
Shucai Xiao's avatar
Shucai Xiao committed
500
    auto prog = optimize_onnx("constant_scalar_test.onnx");
501
502
503
504

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
505
TEST_CASE(const_of_shape_empty_input_test)
Shucai Xiao's avatar
Shucai Xiao committed
506
507
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
508
509
    auto* mm = p.get_main_module();
    mm->add_literal(migraphx::literal());
Khalique's avatar
Khalique committed
510
511
    migraphx::shape s(migraphx::shape::int64_type, {1}, {0});
    std::vector<int64_t> vec(s.elements(), 10);
Shucai Xiao's avatar
Shucai Xiao committed
512
    mm->add_literal(migraphx::literal(s, vec));
Shucai Xiao's avatar
Shucai Xiao committed
513

Shucai Xiao's avatar
Shucai Xiao committed
514
    auto prog = optimize_onnx("const_of_shape_empty_input_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
515
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
516
517
}

Khalique's avatar
Khalique committed
518
TEST_CASE(const_of_shape_float_test)
519
520
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
521
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
522
    migraphx::shape ss(migraphx::shape::int32_type, {3});
Shucai Xiao's avatar
Shucai Xiao committed
523
    mm->add_literal(migraphx::literal(ss, {2, 3, 4}));
Khalique's avatar
Khalique committed
524
525
    migraphx::shape s(migraphx::shape::float_type, {2, 3, 4});
    std::vector<float> vec(s.elements(), 10.0f);
Shucai Xiao's avatar
Shucai Xiao committed
526
    mm->add_literal(migraphx::literal(s, vec));
527

Shucai Xiao's avatar
Shucai Xiao committed
528
    auto prog = optimize_onnx("const_of_shape_float_test.onnx");
529
530
531
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
532
TEST_CASE(const_of_shape_int64_test)
533
534
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
535
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
536
    migraphx::shape ss(migraphx::shape::int32_type, {3});
Shucai Xiao's avatar
Shucai Xiao committed
537
    mm->add_literal(migraphx::literal(ss, {2, 3, 4}));
Khalique's avatar
Khalique committed
538
539
    migraphx::shape s(migraphx::shape::int64_type, {2, 3, 4});
    std::vector<int64_t> vec(s.elements(), 10);
Shucai Xiao's avatar
Shucai Xiao committed
540
    mm->add_literal(migraphx::literal(s, vec));
541

Shucai Xiao's avatar
Shucai Xiao committed
542
    auto prog = optimize_onnx("const_of_shape_int64_test.onnx");
543
544
545
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
546
TEST_CASE(const_of_shape_no_value_attr_test)
547
548
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
549
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
550
    migraphx::shape ss(migraphx::shape::int32_type, {3});
Shucai Xiao's avatar
Shucai Xiao committed
551
    mm->add_literal(migraphx::literal(ss, {2, 3, 4}));
Khalique's avatar
Khalique committed
552
553
    migraphx::shape s(migraphx::shape::float_type, {2, 3, 4});
    std::vector<float> vec(s.elements(), 0.0f);
Shucai Xiao's avatar
Shucai Xiao committed
554
    mm->add_literal(migraphx::literal(s, vec));
555

Shucai Xiao's avatar
Shucai Xiao committed
556
    auto prog = optimize_onnx("const_of_shape_no_value_attr_test.onnx");
557
558
559
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
560
TEST_CASE(conv_autopad_fail_test)
561
{
Shucai Xiao's avatar
Shucai Xiao committed
562
    EXPECT(test::throws([&] { optimize_onnx("conv_autopad_fail_test.onnx"); }));
Khalique's avatar
Khalique committed
563
}
564

565
566
567
TEST_CASE(conv_1d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
568
569
570
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 5}});
    auto l1  = mm->add_parameter("1", {migraphx::shape::float_type, {1, 3, 3}});
571
572
573
574
    mm->add_instruction(
        migraphx::make_op("convolution", {{"padding", {0}}, {"stride", {1}}, {"dilation", {1}}}),
        l0,
        l1);
575
576
577
578
579
580
581
582

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

TEST_CASE(conv_3d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
583
584
585
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 5, 5, 5}});
    auto l1  = mm->add_parameter("1", {migraphx::shape::float_type, {1, 3, 3, 3, 3}});
586
587
588
589
590
    mm->add_instruction(
        migraphx::make_op("convolution",
                          {{"padding", {0, 0, 0}}, {"stride", {1, 1, 1}}, {"dilation", {1, 1, 1}}}),
        l0,
        l1);
591
592
593
594
595
596
597
598
599
600

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

TEST_CASE(conv_attr_fail_test)
{
    EXPECT(test::throws([&] { migraphx::parse_onnx("conv_attr_fail_test.onnx"); }));
}

601
602
603
TEST_CASE(conv_autopad_same_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
604
605
606
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
    auto l1  = mm->add_parameter("1", {migraphx::shape::float_type, {1, 3, 3, 3}});
607
608
609
    migraphx::op::convolution op;
    op.padding      = {1, 1};
    op.padding_mode = migraphx::op::padding_mode_t::same;
Shucai Xiao's avatar
Shucai Xiao committed
610
    mm->add_instruction(op, l0, l1);
611
612
613
614
615

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

Khalique's avatar
Khalique committed
616
617
618
TEST_CASE(conv_bias_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
619
620
621
622
    auto* mm      = p.get_main_module();
    auto l0       = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
    auto l1       = mm->add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}});
    auto l2       = mm->add_parameter("2", {migraphx::shape::float_type, {1}});
Khalique's avatar
Khalique committed
623
    uint64_t axis = 1;
624
625
626
627
    auto l3       = mm->add_instruction(migraphx::make_op("convolution"), l0, l1);
    auto l4       = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", l3->get_shape().lens()}}), l2);
    mm->add_instruction(migraphx::make_op("add"), l3, l4);
Khalique's avatar
Khalique committed
628

Shucai Xiao's avatar
Shucai Xiao committed
629
    auto prog = optimize_onnx("conv_bias_test.onnx");
Khalique's avatar
Khalique committed
630
631
632
633
634
635
    EXPECT(p == prog);
}

TEST_CASE(conv_bn_relu_maxpool_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
636
637
638
639
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
    auto l1  = mm->add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}});
    auto l2  = mm->add_parameter("2", {migraphx::shape::float_type, {1}});
Khalique's avatar
Khalique committed
640

Shucai Xiao's avatar
Shucai Xiao committed
641
642
643
644
    auto p3       = mm->add_parameter("3", {migraphx::shape::float_type, {1}});
    auto p4       = mm->add_parameter("4", {migraphx::shape::float_type, {1}});
    auto p5       = mm->add_parameter("5", {migraphx::shape::float_type, {1}});
    auto p6       = mm->add_parameter("6", {migraphx::shape::float_type, {1}});
Khalique's avatar
Khalique committed
645
    uint64_t axis = 1;
646
647
648
649
650
651
652
653
654
655
656
657
    auto l3       = mm->add_instruction(migraphx::make_op("convolution"), l0, l1);
    auto l4       = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", l3->get_shape().lens()}}), l2);
    auto l5 = mm->add_instruction(migraphx::make_op("add"), l3, l4);
    auto l6 = mm->add_instruction(
        migraphx::make_op("batch_norm_inference", {{"epsilon", 1.0e-5f}}), l5, p3, p4, p5, p6);
    auto l7 = mm->add_instruction(migraphx::make_op("relu"), l6);
    mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "max"}, {"padding", {0, 0}}, {"stride", {2, 2}}, {"lengths", {2, 2}}}),
        l7);
Khalique's avatar
Khalique committed
658

Shucai Xiao's avatar
Shucai Xiao committed
659
    auto prog = optimize_onnx("conv_bn_relu_maxpool_test.onnx");
Khalique's avatar
Khalique committed
660
661
662
663
664
665
    EXPECT(p == prog);
}

TEST_CASE(conv_relu_maxpool_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
666
667
668
669
    auto* mm      = p.get_main_module();
    auto l0       = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
    auto l1       = mm->add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}});
    auto l2       = mm->add_parameter("2", {migraphx::shape::float_type, {1}});
Khalique's avatar
Khalique committed
670
    uint64_t axis = 1;
671
672
673
674
675
676
677
678
679
680
    auto l3       = mm->add_instruction(migraphx::make_op("convolution"), l0, l1);
    auto l4       = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", l3->get_shape().lens()}}), l2);
    auto l5 = mm->add_instruction(migraphx::make_op("add"), l3, l4);
    auto l6 = mm->add_instruction(migraphx::make_op("relu"), l5);
    mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "max"}, {"padding", {0, 0}}, {"stride", {2, 2}}, {"lengths", {2, 2}}}),
        l6);
Khalique's avatar
Khalique committed
681

Shucai Xiao's avatar
Shucai Xiao committed
682
    auto prog = optimize_onnx("conv_relu_maxpool_test.onnx");
Khalique's avatar
Khalique committed
683
684
685
686
687
688
    EXPECT(p == prog);
}

TEST_CASE(conv_relu_maxpool_x2_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
689
690
691
692
    auto* mm      = p.get_main_module();
    auto l0       = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
    auto l1       = mm->add_parameter("1", {migraphx::shape::float_type, {5, 3, 5, 5}});
    auto l2       = mm->add_parameter("2", {migraphx::shape::float_type, {5}});
Khalique's avatar
Khalique committed
693
    uint64_t axis = 1;
694
695
696
697
698
699
700
701
702
703
    auto l3       = mm->add_instruction(migraphx::make_op("convolution"), l0, l1);
    auto l4       = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", l3->get_shape().lens()}}), l2);
    auto l5 = mm->add_instruction(migraphx::make_op("add"), l3, l4);
    auto l6 = mm->add_instruction(migraphx::make_op("relu"), l5);
    auto l7 = mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "max"}, {"padding", {0, 0}}, {"stride", {2, 2}}, {"lengths", {2, 2}}}),
        l6);
Shucai Xiao's avatar
Shucai Xiao committed
704
705
706

    auto l8  = mm->add_parameter("3", {migraphx::shape::float_type, {1, 5, 5, 5}});
    auto l9  = mm->add_parameter("4", {migraphx::shape::float_type, {1}});
707
708
709
710
711
712
713
714
715
716
    auto l10 = mm->add_instruction(migraphx::make_op("convolution"), l7, l8);
    auto l11 = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", l10->get_shape().lens()}}), l9);
    auto l12 = mm->add_instruction(migraphx::make_op("add"), l10, l11);
    auto l13 = mm->add_instruction(migraphx::make_op("relu"), l12);
    mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "max"}, {"padding", {0, 0}}, {"stride", {2, 2}}, {"lengths", {2, 2}}}),
        l13);
Khalique's avatar
Khalique committed
717

Shucai Xiao's avatar
Shucai Xiao committed
718
    auto prog = optimize_onnx("conv_relu_maxpool_x2_test.onnx");
Khalique's avatar
Khalique committed
719
720
721
722

    EXPECT(p == prog);
}

723
724
725
TEST_CASE(convinteger_bias_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
726
727
728
729
    auto* mm      = p.get_main_module();
    auto l0       = mm->add_parameter("0", {migraphx::shape::int8_type, {1, 3, 32, 32}});
    auto l1       = mm->add_parameter("1", {migraphx::shape::int8_type, {1, 3, 5, 5}});
    auto l2       = mm->add_parameter("2", {migraphx::shape::int32_type, {1}});
730
    uint64_t axis = 1;
731
732
733
734
    auto l3       = mm->add_instruction(migraphx::make_op("quant_convolution"), l0, l1);
    auto l4       = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", l3->get_shape().lens()}}), l2);
    mm->add_instruction(migraphx::make_op("add"), l3, l4);
735
736
737
738
739

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

Khalique's avatar
Khalique committed
740
TEST_CASE(cos_test)
741
742
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
743
744
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
745
    mm->add_instruction(migraphx::make_op("cos"), input);
746

Shucai Xiao's avatar
Shucai Xiao committed
747
    auto prog = optimize_onnx("cos_test.onnx");
748
749
750
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
751
TEST_CASE(cosh_test)
752
753
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
754
755
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}});
756
    mm->add_instruction(migraphx::make_op("cosh"), input);
757

Shucai Xiao's avatar
Shucai Xiao committed
758
    auto prog = optimize_onnx("cosh_test.onnx");
759
760
761
762

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
763
764
765
TEST_CASE(deconv_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
766
767
768
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1  = mm->add_parameter("w", {migraphx::shape::float_type, {1, 1, 3, 3}});
769
    mm->add_instruction(migraphx::make_op("deconvolution"), l0, l1);
kahmed10's avatar
kahmed10 committed
770
771
772
773
774
775
776
777

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

TEST_CASE(deconv_bias_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
778
779
780
781
    auto* mm      = p.get_main_module();
    auto l0       = mm->add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1       = mm->add_parameter("w", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l2       = mm->add_parameter("b", {migraphx::shape::float_type, {1}});
kahmed10's avatar
kahmed10 committed
782
    uint64_t axis = 1;
783
784
785
786
    auto l3       = mm->add_instruction(migraphx::make_op("deconvolution"), l0, l1);
    auto l4       = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", l3->get_shape().lens()}}), l2);
    mm->add_instruction(migraphx::make_op("add"), l3, l4);
kahmed10's avatar
kahmed10 committed
787
788
789
790
791
792
793
794

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

TEST_CASE(deconv_input_pads_strides_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
795
796
797
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1  = mm->add_parameter("w", {migraphx::shape::float_type, {1, 2, 3, 3}});
798
799
    mm->add_instruction(
        migraphx::make_op("deconvolution", {{"padding", {1, 1}}, {"stride", {3, 2}}}), l0, l1);
kahmed10's avatar
kahmed10 committed
800
801
802
803
804
805
806
807

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

TEST_CASE(deconv_input_pads_asymm_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
808
809
810
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1  = mm->add_parameter("w", {migraphx::shape::float_type, {1, 2, 3, 3}});
811
812
813
814
    auto l2  = mm->add_instruction(
        migraphx::make_op("deconvolution", {{"padding", {0, 0}}, {"stride", {3, 2}}}), l0, l1);
    mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {2, 3}}, {"starts", {0, 0}}, {"ends", {8, 6}}}), l2);
kahmed10's avatar
kahmed10 committed
815
816
817
818
819

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

kahmed10's avatar
kahmed10 committed
820
821
822
TEST_CASE(deconv_input_pads_asymm_1d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
823
824
825
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {1, 1, 3}});
    auto l1  = mm->add_parameter("w", {migraphx::shape::float_type, {1, 2, 3}});
826
827
828
829
830
831
    auto l2  = mm->add_instruction(
        migraphx::make_op("deconvolution", {{"padding", {0}}, {"stride", {2}}, {"dilation", {1}}}),
        l0,
        l1);
    mm->add_instruction(migraphx::make_op("slice", {{"axes", {2}}, {"starts", {0}}, {"ends", {6}}}),
                        l2);
kahmed10's avatar
kahmed10 committed
832
833
834
835
836
837

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

TEST_CASE(deconv_output_padding_test)
kahmed10's avatar
kahmed10 committed
838
839
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
840
841
842
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1  = mm->add_parameter("w", {migraphx::shape::float_type, {1, 2, 3, 3}});
843
844
845
    auto l2  = mm->add_instruction(
        migraphx::make_op("deconvolution", {{"padding", {0, 0}}, {"stride", {3, 2}}}), l0, l1);
    mm->add_instruction(migraphx::make_op("pad", {{"pads", {0, 0, 0, 0, 0, 0, 1, 1}}}), l2);
kahmed10's avatar
kahmed10 committed
846

kahmed10's avatar
kahmed10 committed
847
    auto prog = optimize_onnx("deconv_output_padding_test.onnx");
kahmed10's avatar
kahmed10 committed
848
849
850
    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
851
852
853
TEST_CASE(deconv_output_padding_3d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
854
855
856
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3, 3}});
    auto l1  = mm->add_parameter("w", {migraphx::shape::float_type, {1, 2, 3, 3, 3}});
857
858
859
860
861
862
    auto l2  = mm->add_instruction(
        migraphx::make_op("deconvolution",
                          {{"padding", {0, 0, 0}}, {"stride", {3, 2, 2}}, {"dilation", {1, 1, 1}}}),
        l0,
        l1);
    mm->add_instruction(migraphx::make_op("pad", {{"pads", {0, 0, 0, 0, 0, 0, 0, 1, 1, 1}}}), l2);
kahmed10's avatar
kahmed10 committed
863
864
865
866
867
868

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

TEST_CASE(deconv_output_shape_test)
kahmed10's avatar
kahmed10 committed
869
870
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
871
872
873
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3}});
    auto l1  = mm->add_parameter("w", {migraphx::shape::float_type, {1, 2, 3, 3}});
874
875
876
    auto l2  = mm->add_instruction(
        migraphx::make_op("deconvolution", {{"padding", {0, 0}}, {"stride", {3, 2}}}), l0, l1);
    mm->add_instruction(migraphx::make_op("pad", {{"pads", {0, 0, 0, 0, 0, 0, 1, 1}}}), l2);
kahmed10's avatar
kahmed10 committed
877

kahmed10's avatar
kahmed10 committed
878
879
880
881
882
883
884
    auto prog = optimize_onnx("deconv_output_shape_test.onnx");
    EXPECT(p == prog);
}

TEST_CASE(deconv_output_shape_3d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
885
886
887
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {1, 1, 3, 3, 3}});
    auto l1  = mm->add_parameter("w", {migraphx::shape::float_type, {1, 2, 3, 3, 3}});
888
889
890
891
892
893
    auto l2  = mm->add_instruction(
        migraphx::make_op("deconvolution",
                          {{"padding", {0, 0, 0}}, {"stride", {3, 2, 2}}, {"dilation", {1, 1, 1}}}),
        l0,
        l1);
    mm->add_instruction(migraphx::make_op("pad", {{"pads", {0, 0, 0, 0, 0, 0, 0, 1, 1, 1}}}), l2);
kahmed10's avatar
kahmed10 committed
894
895

    auto prog = optimize_onnx("deconv_output_shape_3d_test.onnx");
kahmed10's avatar
kahmed10 committed
896
897
898
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
899
TEST_CASE(dropout_test)
Shucai Xiao's avatar
Shucai Xiao committed
900
901
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
902
903
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}});
904
    auto out   = mm->add_instruction(migraphx::make_op("identity"), input);
905
906
    migraphx::shape s{migraphx::shape::bool_type, {1, 3, 2, 2}};
    std::vector<int8_t> vec(s.elements(), 1);
Shucai Xiao's avatar
Shucai Xiao committed
907
908
    mm->add_literal(migraphx::literal(s, vec));
    mm->add_return({out});
Shucai Xiao's avatar
Shucai Xiao committed
909

910
    auto prog = migraphx::parse_onnx("dropout_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
911
912
913
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
914
915
916
TEST_CASE(elu_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
917
918
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
919
    mm->add_instruction(migraphx::make_op("elu", {{"alpha", 0.01}}), input);
Khalique's avatar
Khalique committed
920

Shucai Xiao's avatar
Shucai Xiao committed
921
    auto prog = optimize_onnx("elu_test.onnx");
Khalique's avatar
Khalique committed
922
923
924
925

    EXPECT(p == prog);
}

926
927
928
TEST_CASE(embedding_bag_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
929
930
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("weight", migraphx::shape{migraphx::shape::float_type, {4, 2}});
931
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {3}}, {1, 0, 2}};
Shucai Xiao's avatar
Shucai Xiao committed
932
933
    auto l1 = mm->add_literal(l);
    mm->add_literal(0);
934
935
936
937
938
939
    auto l4 = mm->add_instruction(migraphx::make_op("gather"), l0, l1);
    auto r1 = mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {0}}}), l4);
    auto l5 = mm->add_instruction(migraphx::make_op("gather"), l0, l1);
    auto r2 = mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {0}}}), l5);
    auto l6 = mm->add_instruction(migraphx::make_op("gather"), l0, l1);
    auto r3 = mm->add_instruction(migraphx::make_op("reduce_max", {{"axes", {0}}}), l6);
Shucai Xiao's avatar
Shucai Xiao committed
940
    mm->add_return({r1, r2, r3});
941
942
943
944
945
946
947
948
949
950
951

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

    EXPECT(p == prog);
}

TEST_CASE(embedding_bag_offset_test)
{
    EXPECT(test::throws([&] { migraphx::parse_onnx("embedding_bag_offset_test.onnx"); }));
}

952
953
954
TEST_CASE(equal_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
955
    auto* mm = p.get_main_module();
956
957
958
    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
    std::vector<float> data = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};

Shucai Xiao's avatar
Shucai Xiao committed
959
960
    auto input1 = mm->add_literal(migraphx::literal(s, data));
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
961
962
963
964
965
    auto eq     = mm->add_instruction(migraphx::make_op("equal"), input1, input2);
    auto ret    = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::bool_type)}}),
        eq);
Shucai Xiao's avatar
Shucai Xiao committed
966
    mm->add_return({ret});
967
968
969
970
971
972
973
974
975

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

    EXPECT(p == prog);
}

TEST_CASE(equal_bool_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
976
    auto* mm = p.get_main_module();
977
978
979
    migraphx::shape sf{migraphx::shape::float_type, {2, 3}};
    migraphx::shape sb{migraphx::shape::bool_type, {2, 3}};

Shucai Xiao's avatar
Shucai Xiao committed
980
981
    auto input1 = mm->add_parameter("x1", sf);
    auto input2 = mm->add_parameter("x2", sb);
982
983
984
985
986
    auto cin1   = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::bool_type)}}),
        input1);
    auto ret = mm->add_instruction(migraphx::make_op("equal"), cin1, input2);
Shucai Xiao's avatar
Shucai Xiao committed
987
    mm->add_return({ret});
988
989
990
991
992
993

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
994
TEST_CASE(erf_test)
995
996
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
997
998
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
999
    mm->add_instruction(migraphx::make_op("erf"), input);
Khalique's avatar
Khalique committed
1000

Shucai Xiao's avatar
Shucai Xiao committed
1001
    auto prog = optimize_onnx("erf_test.onnx");
Khalique's avatar
Khalique committed
1002
1003
1004
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1005
TEST_CASE(exp_test)
1006
1007
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1008
1009
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
1010
    mm->add_instruction(migraphx::make_op("exp"), input);
Khalique's avatar
Khalique committed
1011

Shucai Xiao's avatar
Shucai Xiao committed
1012
    auto prog = optimize_onnx("exp_test.onnx");
Khalique's avatar
Khalique committed
1013
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
1014
1015
}

Khalique's avatar
Khalique committed
1016
TEST_CASE(expand_test)
1017
1018
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1019
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
1020
    migraphx::shape s(migraphx::shape::float_type, {3, 1, 1});
Shucai Xiao's avatar
Shucai Xiao committed
1021
    auto param = mm->add_parameter("x", s);
Khalique's avatar
Khalique committed
1022
    migraphx::shape ss(migraphx::shape::int32_type, {4});
Shucai Xiao's avatar
Shucai Xiao committed
1023
    mm->add_literal(migraphx::literal(ss, {2, 3, 4, 5}));
1024
1025
    mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 4, 5}}}),
                        param);
Khalique's avatar
Khalique committed
1026

Shucai Xiao's avatar
Shucai Xiao committed
1027
    auto prog = optimize_onnx("expand_test.onnx");
Khalique's avatar
Khalique committed
1028
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
1029
1030
}

1031
1032
1033
migraphx::program create_external_data_prog()
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1034
    auto* mm = p.get_main_module();
1035
1036
1037
1038
    migraphx::shape s(migraphx::shape::float_type, {1, 1, 224, 224});
    migraphx::shape s2(migraphx::shape::float_type, {10, 1, 11, 11});
    std::vector<float> weight_data(1210, 1);
    std::vector<float> bias_data(10, 1);
Shucai Xiao's avatar
Shucai Xiao committed
1039
1040
1041
1042
1043
    auto bias = mm->add_literal(migraphx::literal({migraphx::shape::float_type, {10}}, bias_data));
    auto weights    = mm->add_literal(migraphx::literal(s2, weight_data));
    auto param      = mm->add_parameter("input", s);
    auto conv       = mm->add_instruction(migraphx::make_op("convolution"), param, weights);
    auto bias_bcast = mm->add_instruction(
1044
        migraphx::make_op("broadcast", {{"axis", 1}, {"dims", {1, 10, 214, 214}}}), bias);
Shucai Xiao's avatar
Shucai Xiao committed
1045
    mm->add_instruction(migraphx::make_op("add"), conv, bias_bcast);
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
    return p;
}

TEST_CASE(external_data_test)
{
    migraphx::program p = create_external_data_prog();

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

TEST_CASE(external_data_diff_path_test)
{
    migraphx::program p = create_external_data_prog();

    auto prog = optimize_onnx("ext_path/external_data_test.onnx");
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1065
TEST_CASE(flatten_test)
1066
1067
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1068
1069
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
1070
1071
    mm->add_instruction(migraphx::make_op("flatten", {{"axis", 2}}), l0);
    mm->add_instruction(migraphx::make_op("flatten", {{"axis", 1}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
1072
    auto prog = optimize_onnx("flatten_test.onnx");
1073
1074
1075
1076

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1077
1078
1079
TEST_CASE(floor_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1080
1081
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
1082
    mm->add_instruction(migraphx::make_op("floor"), input);
Shucai Xiao's avatar
Shucai Xiao committed
1083

Shucai Xiao's avatar
Shucai Xiao committed
1084
    auto prog = optimize_onnx("floor_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1085
1086
1087
1088

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1089
TEST_CASE(gather_test)
1090
1091
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1092
1093
1094
    auto* mm = p.get_main_module();
    auto l0 = mm->add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto l1 = mm->add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 3}});
Khalique's avatar
Khalique committed
1095
    int axis = 1;
1096
    mm->add_instruction(migraphx::make_op("gather", {{"axis", axis}}), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1097
    auto prog = optimize_onnx("gather_test.onnx");
1098
1099
1100
1101

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1102
1103
1104
TEST_CASE(gather_elements_axis0_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1105
1106
1107
    auto* mm     = p.get_main_module();
    auto data    = mm->add_parameter("data", {migraphx::shape::float_type, {3, 4}});
    auto indices = mm->add_parameter("indices", {migraphx::shape::int32_type, {2, 3}});
Shucai Xiao's avatar
Shucai Xiao committed
1108
1109
1110
1111
    std::vector<int> ind_indices{0, 1, 2, 4, 5, 6};
    std::vector<int> ind_axis_indices{0, 0, 0, 1, 1, 1};
    migraphx::shape ind_s{migraphx::shape::int32_type, {2, 3}};
    auto l_data_indices =
Shucai Xiao's avatar
Shucai Xiao committed
1112
        mm->add_literal(migraphx::literal{ind_s, ind_indices.begin(), ind_indices.end()});
Shucai Xiao's avatar
Shucai Xiao committed
1113
    auto l_ind_axis_indices =
Shucai Xiao's avatar
Shucai Xiao committed
1114
1115
        mm->add_literal(migraphx::literal{ind_s, ind_axis_indices.begin(), ind_axis_indices.end()});
    auto l_stride = mm->add_literal(migraphx::literal{{migraphx::shape::int32_type, {1}}, {4}});
Shucai Xiao's avatar
Shucai Xiao committed
1116

1117
1118
1119
1120
1121
1122
1123
    auto rsp_data    = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {12}}}), data);
    auto lbst_stride = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", ind_s.lens()}}), l_stride);
    auto axis_delta = mm->add_instruction(migraphx::make_op("sub"), indices, l_ind_axis_indices);
    auto mul_delta  = mm->add_instruction(migraphx::make_op("mul"), axis_delta, lbst_stride);
    auto ind        = mm->add_instruction(migraphx::make_op("add"), l_data_indices, mul_delta);
    auto ret = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), rsp_data, ind);
Shucai Xiao's avatar
Shucai Xiao committed
1124
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1125
1126
1127
1128
1129
1130
1131
1132
1133

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

    EXPECT(p == prog);
}

TEST_CASE(gather_elements_axis1_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1134
1135
1136
    auto* mm     = p.get_main_module();
    auto data    = mm->add_parameter("data", {migraphx::shape::float_type, {3, 4}});
    auto indices = mm->add_parameter("indices", {migraphx::shape::int32_type, {2, 3}});
Shucai Xiao's avatar
Shucai Xiao committed
1137
1138
1139
1140
    std::vector<int> ind_indices{0, 1, 2, 4, 5, 6};
    std::vector<int> ind_axis_indices{0, 1, 2, 0, 1, 2};
    migraphx::shape ind_s{migraphx::shape::int32_type, {2, 3}};
    auto l_data_indices =
Shucai Xiao's avatar
Shucai Xiao committed
1141
        mm->add_literal(migraphx::literal{ind_s, ind_indices.begin(), ind_indices.end()});
Shucai Xiao's avatar
Shucai Xiao committed
1142
    auto l_ind_axis_indices =
Shucai Xiao's avatar
Shucai Xiao committed
1143
1144
        mm->add_literal(migraphx::literal{ind_s, ind_axis_indices.begin(), ind_axis_indices.end()});
    auto l_stride = mm->add_literal(migraphx::literal{{migraphx::shape::int32_type, {1}}, {1}});
Shucai Xiao's avatar
Shucai Xiao committed
1145

1146
1147
1148
1149
1150
1151
1152
    auto rsp_data    = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {12}}}), data);
    auto lbst_stride = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", ind_s.lens()}}), l_stride);
    auto axis_delta = mm->add_instruction(migraphx::make_op("sub"), indices, l_ind_axis_indices);
    auto mul_delta  = mm->add_instruction(migraphx::make_op("mul"), axis_delta, lbst_stride);
    auto ind        = mm->add_instruction(migraphx::make_op("add"), l_data_indices, mul_delta);
    auto ret = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), rsp_data, ind);
Shucai Xiao's avatar
Shucai Xiao committed
1153
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1154
1155
1156
1157
1158
1159

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1160
TEST_CASE(gemm_test)
1161
1162
{
    migraphx::program p;
1163
1164
1165
1166
1167
1168
1169
1170
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 7}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {11, 5}});
    auto l2  = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type});
    auto t0  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), l0);
    auto t1  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), l1);
    auto bl2 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {7, 11}}}), l2);
Khalique's avatar
Khalique committed
1171
1172
    auto alpha = 2.f;
    auto beta  = 2.0f;
1173
    mm->add_instruction(migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), t0, t1, bl2);
Shucai Xiao's avatar
Shucai Xiao committed
1174
    auto prog = optimize_onnx("gemm_test.onnx");
1175
1176
1177
1178

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1179
TEST_CASE(gemm_ex_test)
1180
1181
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1182
1183
1184
1185
    auto* mm   = p.get_main_module();
    auto l0    = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 8, 6}});
    auto l1    = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 1, 8, 7}});
    auto l2    = mm->add_parameter("3", migraphx::shape{migraphx::shape::float_type, {1, 1, 6, 7}});
1186
    auto t0    = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 1, 3, 2}}}), l0);
Khalique's avatar
Khalique committed
1187
1188
    auto alpha = 0.5f;
    auto beta  = 0.8f;
1189
    mm->add_instruction(migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), t0, l1, l2);
Shucai Xiao's avatar
Shucai Xiao committed
1190
    auto prog = optimize_onnx("gemm_ex_test.onnx");
1191
1192
1193
1194

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1195
TEST_CASE(gemm_ex_brcst_test)
1196
1197
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1198
1199
1200
1201
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 6}});
    auto l1  = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 7}});
    auto l2  = mm->add_parameter("3", migraphx::shape{migraphx::shape::float_type, {1, 1, 6, 1}});
1202
    auto t0  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 1, 3, 2}}}), l0);
Khalique's avatar
Khalique committed
1203
    std::vector<std::size_t> out_lens{1, 1, 6, 7};
1204
1205
    auto t2 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", out_lens}}), l2);
Khalique's avatar
Khalique committed
1206
1207
    auto alpha = 0.5f;
    auto beta  = 0.8f;
1208
    mm->add_instruction(migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), t0, l1, t2);
Shucai Xiao's avatar
Shucai Xiao committed
1209
    auto prog = optimize_onnx("gemm_ex_brcst_test.onnx");
1210
1211
1212
1213

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1214
TEST_CASE(globalavgpool_test)
1215
1216
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1217
1218
1219
    auto* mm = p.get_main_module();
    auto input =
        mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
Khalique's avatar
Khalique committed
1220
1221
1222
    auto op    = migraphx::op::pooling{"average"};
    auto lens  = input->get_shape().lens();
    op.lengths = {lens[2], lens[3]};
Shucai Xiao's avatar
Shucai Xiao committed
1223
    mm->add_instruction(op, input);
Khalique's avatar
Khalique committed
1224

Shucai Xiao's avatar
Shucai Xiao committed
1225
    auto prog = optimize_onnx("globalavgpool_test.onnx");
1226
1227
1228
1229

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1230
TEST_CASE(globalmaxpool_test)
Khalique's avatar
Khalique committed
1231
1232
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1233
1234
1235
    auto* mm = p.get_main_module();
    auto input =
        mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
Khalique's avatar
Khalique committed
1236
1237
1238
    auto op    = migraphx::op::pooling{"max"};
    auto lens  = input->get_shape().lens();
    op.lengths = {lens[2], lens[3]};
Shucai Xiao's avatar
Shucai Xiao committed
1239
    mm->add_instruction(op, input);
Khalique's avatar
Khalique committed
1240

Shucai Xiao's avatar
Shucai Xiao committed
1241
    auto prog = optimize_onnx("globalmaxpool_test.onnx");
Khalique's avatar
Khalique committed
1242
1243
1244
1245

    EXPECT(p == prog);
}

1246
1247
1248
TEST_CASE(greater_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1249
    auto* mm = p.get_main_module();
1250
1251
1252
    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
    std::vector<float> data = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};

Shucai Xiao's avatar
Shucai Xiao committed
1253
1254
    auto input1 = mm->add_literal(migraphx::literal(s, data));
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
1255
1256
1257
1258
1259
    auto gr     = mm->add_instruction(migraphx::make_op("greater"), input1, input2);
    auto ret    = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::bool_type)}}),
        gr);
Shucai Xiao's avatar
Shucai Xiao committed
1260
    mm->add_return({ret});
1261
1262
1263
1264
1265
1266
1267
1268

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

TEST_CASE(greater_bool_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1269
    auto* mm = p.get_main_module();
1270
1271
1272
    migraphx::shape sf{migraphx::shape::float_type, {2, 3}};
    migraphx::shape sb{migraphx::shape::bool_type, {2, 3}};

Shucai Xiao's avatar
Shucai Xiao committed
1273
1274
    auto input1 = mm->add_parameter("x1", sf);
    auto input2 = mm->add_parameter("x2", sb);
1275
1276
1277
1278
1279
    auto cin1   = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::bool_type)}}),
        input1);
    auto ret = mm->add_instruction(migraphx::make_op("greater"), cin1, input2);
Shucai Xiao's avatar
Shucai Xiao committed
1280
    mm->add_return({ret});
1281
1282
1283
1284
1285

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

Khalique's avatar
Khalique committed
1286
TEST_CASE(group_conv_test)
1287
1288
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1289
1290
1291
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 4, 16, 16}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 1, 3, 3}});
Khalique's avatar
Khalique committed
1292
1293
    migraphx::op::convolution op;
    op.group = 4;
Shucai Xiao's avatar
Shucai Xiao committed
1294
    mm->add_instruction(op, l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1295
    auto prog = optimize_onnx("group_conv_test.onnx");
1296
1297
1298
1299

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1300
TEST_CASE(imagescaler_test)
1301
1302
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1303
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
1304
    migraphx::shape s{migraphx::shape::float_type, {1, 3, 16, 16}};
Shucai Xiao's avatar
Shucai Xiao committed
1305
1306
1307
    auto l0        = mm->add_parameter("0", s);
    auto scale_val = mm->add_literal(0.5f);
    auto bias_vals = mm->add_literal(
Khalique's avatar
Khalique committed
1308
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
1309
1310
1311
1312
1313
1314
    auto scaled_tensor = mm->add_instruction(
        migraphx::make_op("scalar", {{"scalar_bcst_dims", s.lens()}}), scale_val);
    auto img_scaled = mm->add_instruction(migraphx::make_op("mul"), l0, scaled_tensor);
    auto bias_bcast = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", 1}, {"dims", s.lens()}}), bias_vals);
    mm->add_instruction(migraphx::make_op("add"), img_scaled, bias_bcast);
Khalique's avatar
Khalique committed
1315

Shucai Xiao's avatar
Shucai Xiao committed
1316
    auto prog = optimize_onnx("imagescaler_test.onnx");
1317
1318
1319
1320

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1321
1322
1323
TEST_CASE(imagescaler_half_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1324
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1325
    migraphx::shape s{migraphx::shape::half_type, {1, 3, 16, 16}};
Shucai Xiao's avatar
Shucai Xiao committed
1326
    auto l0 = mm->add_parameter("0", s);
Shucai Xiao's avatar
Shucai Xiao committed
1327
    auto scale_val =
Shucai Xiao's avatar
Shucai Xiao committed
1328
1329
        mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type}, {0.5f}});
    auto bias_vals = mm->add_literal(
Shucai Xiao's avatar
Shucai Xiao committed
1330
        migraphx::literal{migraphx::shape{migraphx::shape::half_type, {3}}, {0.01, 0.02, 0.03}});
1331
1332
1333
1334
1335
1336
    auto scaled_tensor = mm->add_instruction(
        migraphx::make_op("scalar", {{"scalar_bcst_dims", s.lens()}}), scale_val);
    auto img_scaled = mm->add_instruction(migraphx::make_op("mul"), l0, scaled_tensor);
    auto bias_bcast = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", 1}, {"dims", s.lens()}}), bias_vals);
    mm->add_instruction(migraphx::make_op("add"), img_scaled, bias_bcast);
Shucai Xiao's avatar
Shucai Xiao committed
1337
1338
1339
1340
1341
1342

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1343
TEST_CASE(implicit_add_bcast_test)
1344
1345
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1346
1347
1348
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4, 1}});
1349
1350
1351
    auto l3  = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 4, 5}}}), l1);
    mm->add_instruction(migraphx::make_op("add"), l0, l3);
Khalique's avatar
Khalique committed
1352

Shucai Xiao's avatar
Shucai Xiao committed
1353
    auto prog = optimize_onnx("implicit_add_bcast_test.onnx");
1354
1355
1356
1357

    EXPECT(p == prog);
}

1358
1359
1360
TEST_CASE(implicit_add_bcast_user_input_shape_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1361
1362
1363
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 5, 1}});
1364
1365
1366
    auto l3  = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {3, 4, 5, 6}}}), l1);
    auto r = mm->add_instruction(migraphx::make_op("add"), l0, l3);
Shucai Xiao's avatar
Shucai Xiao committed
1367
    mm->add_return({r});
1368
1369
1370
1371
1372
1373
1374
1375
1376

    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
1377
TEST_CASE(implicit_pow_bcast_test)
1378
1379
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1380
1381
1382
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4, 1}});
1383
1384
1385
    auto l3  = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 4, 5}}}), l1);
    mm->add_instruction(migraphx::make_op("pow"), l0, l3);
Khalique's avatar
Khalique committed
1386

Shucai Xiao's avatar
Shucai Xiao committed
1387
    auto prog = optimize_onnx("implicit_pow_bcast_test.onnx");
1388
1389
1390
1391

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1392
TEST_CASE(implicit_sub_bcast_test)
1393
1394
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1395
1396
1397
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::uint64_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::uint64_type, {4, 5}});
1398
1399
1400
    auto l3  = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 4, 5}}}), l1);
    mm->add_instruction(migraphx::make_op("sub"), l0, l3);
Khalique's avatar
Khalique committed
1401

Shucai Xiao's avatar
Shucai Xiao committed
1402
    auto prog = optimize_onnx("implicit_sub_bcast_test.onnx");
1403
1404
1405
1406

    EXPECT(p == prog);
}

1407
1408
1409
TEST_CASE(initializer_not_an_input)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1410
    auto* mm             = p.get_main_module();
1411
    std::vector<float> w = {1, 2, 3, 4, 5, 6, 7, 8};
Shucai Xiao's avatar
Shucai Xiao committed
1412
1413
    auto l1 = mm->add_literal(migraphx::literal({migraphx::shape::float_type, {2, 4}}, w));
    auto l0 = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {5, 2}});
1414
    mm->add_instruction(migraphx::make_op("dot"), l0, l1);
1415

Shucai Xiao's avatar
Shucai Xiao committed
1416
    auto prog = optimize_onnx("initializer_not_an_input.onnx");
kahmed10's avatar
kahmed10 committed
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427

    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;
Shucai Xiao's avatar
Shucai Xiao committed
1428
1429
1430
1431
1432
    auto* mm   = p.get_main_module();
    auto x     = mm->add_parameter("0", s1);
    auto scale = mm->add_parameter("1", s2);
    auto bias  = mm->add_parameter("2", s2);

1433
1434
1435
1436
1437
1438
    auto mean = mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2, 3}}}), x);
    auto mean_bcast =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", dims}}), mean);
    auto l0       = mm->add_instruction(migraphx::make_op("sqdiff"), x, mean_bcast);
    auto variance = mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2, 3}}}), l0);
    auto l1       = mm->add_instruction(migraphx::make_op("sub"), x, mean_bcast);
Shucai Xiao's avatar
Shucai Xiao committed
1439
    auto epsilon_literal = mm->add_literal(1e-5f);
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
    auto epsilon_bcast   = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", dims}}), epsilon_literal);
    auto variance_bcast =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", dims}}), variance);
    auto l2 = mm->add_instruction(migraphx::make_op("add"), variance_bcast, epsilon_bcast);
    auto l3 = mm->add_instruction(migraphx::make_op("rsqrt"), l2);
    auto l4 = mm->add_instruction(migraphx::make_op("mul"), l1, l3);
    auto scale_bcast =
        mm->add_instruction(migraphx::make_op("broadcast", {{"axis", 1}, {"dims", dims}}), scale);
    auto bias_bcast =
        mm->add_instruction(migraphx::make_op("broadcast", {{"axis", 1}, {"dims", dims}}), bias);
    auto l5 = mm->add_instruction(migraphx::make_op("mul"), l4, scale_bcast);
    mm->add_instruction(migraphx::make_op("add"), l5, bias_bcast);
kahmed10's avatar
kahmed10 committed
1453
1454

    auto prog = optimize_onnx("instance_norm_test.onnx");
1455
1456
1457
1458

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1459
TEST_CASE(leaky_relu_test)
1460
1461
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1462
    auto* mm    = p.get_main_module();
Khalique's avatar
Khalique committed
1463
    float alpha = 0.01f;
Shucai Xiao's avatar
Shucai Xiao committed
1464
    auto l0     = mm->add_parameter("0", {migraphx::shape::float_type, {3}});
1465
    mm->add_instruction(migraphx::make_op("leaky_relu", {{"alpha", alpha}}), l0);
Khalique's avatar
Khalique committed
1466

Shucai Xiao's avatar
Shucai Xiao committed
1467
    auto prog = optimize_onnx("leaky_relu_test.onnx");
1468
1469
1470
1471

    EXPECT(p == prog);
}

1472
1473
1474
TEST_CASE(less_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1475
    auto* mm = p.get_main_module();
1476
1477
1478
    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
    std::vector<float> data = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};

Shucai Xiao's avatar
Shucai Xiao committed
1479
1480
    auto input1 = mm->add_literal(migraphx::literal(s, data));
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
1481
1482
1483
1484
1485
    auto le     = mm->add_instruction(migraphx::make_op("less"), input1, input2);
    auto ret    = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::bool_type)}}),
        le);
Shucai Xiao's avatar
Shucai Xiao committed
1486
    mm->add_return({ret});
1487
1488
1489
1490
1491
1492
1493
1494

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

TEST_CASE(less_bool_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1495
    auto* mm = p.get_main_module();
1496
1497
1498
    migraphx::shape sf{migraphx::shape::float_type, {2, 3}};
    migraphx::shape sb{migraphx::shape::bool_type, {2, 3}};

Shucai Xiao's avatar
Shucai Xiao committed
1499
1500
    auto input1 = mm->add_parameter("x1", sf);
    auto input2 = mm->add_parameter("x2", sb);
1501
1502
1503
1504
1505
    auto cin1   = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::bool_type)}}),
        input1);
    auto ret = mm->add_instruction(migraphx::make_op("less"), cin1, input2);
Shucai Xiao's avatar
Shucai Xiao committed
1506
    mm->add_return({ret});
1507
1508
1509
1510
1511

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

Khalique's avatar
Khalique committed
1512
TEST_CASE(log_test)
1513
1514
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1515
1516
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
1517
    mm->add_instruction(migraphx::make_op("log"), input);
1518

Shucai Xiao's avatar
Shucai Xiao committed
1519
    auto prog = optimize_onnx("log_test.onnx");
1520
1521
1522
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1523
TEST_CASE(logsoftmax_test)
1524
1525
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1526
1527
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
Khalique's avatar
Khalique committed
1528
    int axis = 1;
1529
    mm->add_instruction(migraphx::make_op("logsoftmax", {{"axis", axis}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
1530
    auto prog = optimize_onnx("logsoftmax_test.onnx");
1531
1532
1533
1534

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1535
TEST_CASE(lrn_test)
1536
1537
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1538
1539
    auto* mm = p.get_main_module();
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 28, 24, 24}});
Khalique's avatar
Khalique committed
1540
1541
1542
1543
1544
    migraphx::op::lrn op;
    op.size  = 5;
    op.alpha = 0.0001;
    op.beta  = 0.75;
    op.bias  = 1.0;
Shucai Xiao's avatar
Shucai Xiao committed
1545
    mm->add_instruction(op, l0);
Shucai Xiao's avatar
Shucai Xiao committed
1546
    auto prog = optimize_onnx("lrn_test.onnx");
1547
1548
1549
1550

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1551
TEST_CASE(matmul_bmbm_test)
1552
1553
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1554
1555
1556
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 6, 7}});
    auto l1 = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {5, 2, 1, 7, 8}});
1557
1558
1559
1560
1561
    auto bl0 = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {5, 2, 3, 6, 7}}}), l0);
    auto bl1 = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {5, 2, 3, 7, 8}}}), l1);
    mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), bl0, bl1);
Khalique's avatar
Khalique committed
1562

Shucai Xiao's avatar
Shucai Xiao committed
1563
    auto prog = optimize_onnx("matmul_bmbm_test.onnx");
1564
1565
1566
1567

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1568
TEST_CASE(matmul_bmv_test)
1569
{
Khalique's avatar
Khalique committed
1570
    migraphx::program p;
1571
1572
1573
1574
1575
1576
1577
1578
1579
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 6, 7}});
    auto l1  = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7}});
    auto sl1 = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1}}}), l1);
    auto bsl1 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {3, 7, 1}}}), sl1);
    auto res =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), l0, bsl1);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {2}}}), res);
1580

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

Khalique's avatar
Khalique committed
1583
    EXPECT(p == prog);
1584
1585
}

Khalique's avatar
Khalique committed
1586
TEST_CASE(matmul_mv_test)
1587
1588
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1589
1590
1591
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {6, 7}});
    auto l1  = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7}});
1592
1593
1594
1595
    auto sl1 = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1}}}), l1);
    auto res =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), l0, sl1);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {1}}}), res);
Khalique's avatar
Khalique committed
1596

Shucai Xiao's avatar
Shucai Xiao committed
1597
    auto prog = optimize_onnx("matmul_mv_test.onnx");
1598
1599
1600
1601

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1602
TEST_CASE(matmul_vbm_test)
1603
1604
{
    migraphx::program p;
1605
1606
1607
1608
1609
1610
1611
1612
1613
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}});
    auto l1  = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {5, 7, 8}});
    auto sl0 = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {0}}}), l0);
    auto bsl0 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {5, 1, 7}}}), sl0);
    auto res =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), bsl0, l1);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {1}}}), res);
Khalique's avatar
Khalique committed
1614

Shucai Xiao's avatar
Shucai Xiao committed
1615
    auto prog = optimize_onnx("matmul_vbm_test.onnx");
1616
1617
1618
1619

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1620
TEST_CASE(matmul_vm_test)
1621
1622
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1623
1624
1625
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}});
    auto l1  = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7, 8}});
1626
1627
1628
1629
    auto sl0 = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {0}}}), l0);
    auto res =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), sl0, l1);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {0}}}), res);
Khalique's avatar
Khalique committed
1630

Shucai Xiao's avatar
Shucai Xiao committed
1631
    auto prog = optimize_onnx("matmul_vm_test.onnx");
1632
1633
1634
1635

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1636
TEST_CASE(matmul_vv_test)
1637
1638
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1639
1640
1641
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}});
    auto l1  = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7}});
1642
1643
1644
1645
1646
1647
    auto sl0 = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {0}}}), l0);
    auto sl1 = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1}}}), l1);
    auto res =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), sl0, sl1);
    auto sr0 = mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {0}}}), res);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {0}}}), sr0);
1648

Shucai Xiao's avatar
Shucai Xiao committed
1649
    auto prog = optimize_onnx("matmul_vv_test.onnx");
1650
1651
1652
1653

    EXPECT(p == prog);
}

1654
1655
1656
TEST_CASE(matmulinteger_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1657
1658
1659
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("1", migraphx::shape{migraphx::shape::int8_type, {3, 6, 16}});
    auto l1  = mm->add_parameter("2", migraphx::shape{migraphx::shape::int8_type, {3, 16, 8}});
1660
    mm->add_instruction(migraphx::make_op("quant_dot", {{"alpha", 1}, {"beta", 0}}), l0, l1);
1661
1662
1663
1664
1665
1666

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1667
TEST_CASE(max_test)
1668
1669
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1670
1671
1672
1673
    auto* mm    = p.get_main_module();
    auto input0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input1 = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input2 = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
1674
1675
    auto l0     = mm->add_instruction(migraphx::make_op("max"), input0, input1);
    mm->add_instruction(migraphx::make_op("max"), l0, input2);
1676

Shucai Xiao's avatar
Shucai Xiao committed
1677
    optimize_onnx("max_test.onnx");
Khalique's avatar
Khalique committed
1678
}
1679

1680
1681
1682
TEST_CASE(maxpool_notset_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1683
1684
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
1685
1686
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
    float val                 = std::numeric_limits<float>::lowest();
1687
1688
1689
1690
1691
1692
1693
    auto ins_pad =
        mm->add_instruction(migraphx::make_op("pad", {{"pads", pads}, {"value", val}}), input);
    mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "max"}, {"padding", {0, 0}}, {"stride", {2, 2}}, {"lengths", {6, 6}}}),
        ins_pad);
1694
1695
1696
1697
1698
1699
1700
1701
1702

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

    EXPECT(p == prog);
}

TEST_CASE(maxpool_same_upper_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1703
1704
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
1705
1706
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
    float val                 = std::numeric_limits<float>::lowest();
1707
1708
1709
1710
1711
1712
1713
    auto ins_pad =
        mm->add_instruction(migraphx::make_op("pad", {{"pads", pads}, {"value", val}}), input);
    mm->add_instruction(
        migraphx::make_op(
            "pooling",
            {{"mode", "max"}, {"padding", {0, 0}}, {"stride", {1, 1}}, {"lengths", {2, 2}}}),
        ins_pad);
1714
1715
1716
1717
1718
1719

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1720
1721
1722
TEST_CASE(min_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1723
1724
1725
1726
    auto* mm    = p.get_main_module();
    auto input0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input1 = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input2 = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
1727
1728
    auto l0     = mm->add_instruction(migraphx::make_op("min"), input0, input1);
    mm->add_instruction(migraphx::make_op("min"), l0, input2);
Khalique's avatar
Khalique committed
1729

Shucai Xiao's avatar
Shucai Xiao committed
1730
    optimize_onnx("min_test.onnx");
1731
1732
}

Khalique's avatar
Khalique committed
1733
TEST_CASE(no_pad_test)
1734
1735
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1736
1737
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
1738
    mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
1739
    auto prog = optimize_onnx("no_pad_test.onnx");
1740

Khalique's avatar
Khalique committed
1741
1742
1743
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1744
1745
1746
TEST_CASE(neg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1747
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1748
    migraphx::shape s{migraphx::shape::int64_type, {2, 3}};
Shucai Xiao's avatar
Shucai Xiao committed
1749
    auto input = mm->add_parameter("0", s);
1750
    auto ret   = mm->add_instruction(migraphx::make_op("neg"), input);
Shucai Xiao's avatar
Shucai Xiao committed
1751
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1752
1753
1754
1755
1756
1757

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1758
1759
1760
TEST_CASE(nonzero_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1761
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1762
1763
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
    std::vector<float> data = {1, 0, 1, 1};
Shucai Xiao's avatar
Shucai Xiao committed
1764
    mm->add_literal(migraphx::literal(s, data));
Shucai Xiao's avatar
Shucai Xiao committed
1765
1766
1767

    migraphx::shape si{migraphx::shape::int64_type, {2, 3}};
    std::vector<int64_t> indices = {0, 1, 1, 0, 0, 1};
Shucai Xiao's avatar
Shucai Xiao committed
1768
1769
    auto r                       = mm->add_literal(migraphx::literal(si, indices));
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1770
1771
1772
1773
1774
1775
1776
1777

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

TEST_CASE(nonzero_int_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1778
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1779
    migraphx::shape s{migraphx::shape::int16_type, {2, 3}};
Shucai Xiao's avatar
Shucai Xiao committed
1780
    std::vector<int> data = {1, 1, 0, 1, 0, 1};
Shucai Xiao's avatar
Shucai Xiao committed
1781
    mm->add_literal(migraphx::literal(s, data.begin(), data.end()));
Shucai Xiao's avatar
Shucai Xiao committed
1782
1783
1784

    migraphx::shape si{migraphx::shape::int64_type, {2, 4}};
    std::vector<int64_t> indices = {0, 0, 1, 1, 0, 1, 0, 2};
Shucai Xiao's avatar
Shucai Xiao committed
1785
1786
    auto r                       = mm->add_literal(migraphx::literal(si, indices));
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1787
1788
1789
1790
1791

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

kahmed10's avatar
kahmed10 committed
1792
1793
1794
TEST_CASE(onehot_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1795
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1796
1797
    migraphx::shape s_ind{migraphx::shape::int32_type, {5, 2}};
    migraphx::shape s_val{migraphx::shape::half_type, {2}};
Shucai Xiao's avatar
Shucai Xiao committed
1798
1799
1800
    mm->add_literal(3);
    auto l_ind = mm->add_parameter("indices", s_ind);
    auto l_val = mm->add_parameter("values", s_val);
Shucai Xiao's avatar
Shucai Xiao committed
1801
1802
    migraphx::shape s_dep{migraphx::shape::half_type, {3, 3}};
    std::vector<float> data_dep{1, 0, 0, 0, 1, 0, 0, 0, 1};
Shucai Xiao's avatar
Shucai Xiao committed
1803
    auto l_dep      = mm->add_literal(migraphx::literal(s_dep, data_dep));
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
    auto gather_out = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), l_dep, l_ind);
    auto tr_out =
        mm->add_instruction(migraphx::make_op("transpose", {{"dims", {2, 0, 1}}}), gather_out);
    auto off_val = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {1}}}), l_val);
    auto on_val = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {1}}, {"ends", {2}}}), l_val);
    auto diff       = mm->add_instruction(migraphx::make_op("sub"), on_val, off_val);
    auto mb_off_val = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {3, 5, 2}}}), off_val);
    auto mb_diff = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {3, 5, 2}}}), diff);
    auto mul = mm->add_instruction(migraphx::make_op("mul"), tr_out, mb_diff);
    auto r   = mm->add_instruction(migraphx::make_op("add"), mul, mb_off_val);
Shucai Xiao's avatar
Shucai Xiao committed
1818
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1819
1820

    auto prog = migraphx::parse_onnx("onehot_test.onnx");
kahmed10's avatar
kahmed10 committed
1821
1822
1823
1824

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1825
1826
1827
TEST_CASE(pad_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1828
1829
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
1830
    mm->add_instruction(migraphx::make_op("pad", {{"pads", {1, 1, 1, 1}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
1831
    auto prog = optimize_onnx("pad_test.onnx");
1832
1833
1834
1835

    EXPECT(p == prog);
}

1836
1837
1838
TEST_CASE(pad_3arg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1839
1840
1841
1842
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
    mm->add_literal({migraphx::shape{migraphx::shape::float_type}, {1.0f}});
    mm->add_literal({migraphx::shape{migraphx::shape::int32_type, {4}}, {1, 1, 2, 2}});
1843
1844
    auto r = mm->add_instruction(
        migraphx::make_op("pad", {{"pads", {1, 1, 2, 2}}, {"value", 1.0f}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
1845
    mm->add_return({r});
1846
1847
1848
1849
1850
1851

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1852
1853
1854
TEST_CASE(pad_reflect_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1855
1856
1857
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
    mm->add_literal({migraphx::shape{migraphx::shape::int32_type, {4}}, {0, 2, 0, 1}});
1858
1859
1860
1861
1862
1863
1864
    auto l1 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {0, 1}}, {"ends", {2, 2}}}), l0);
    auto l2 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {0, 0}}, {"ends", {2, 1}}}), l0);
    auto l3 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {0, 0}}, {"ends", {2, 1}}}), l0);
    auto r = mm->add_instruction(migraphx::make_op("concat", {{"axis", 1}}), l2, l1, l0, l3);
Shucai Xiao's avatar
Shucai Xiao committed
1865
    mm->add_return({r});
kahmed10's avatar
kahmed10 committed
1866
1867
1868
1869
1870
1871
1872
1873
1874

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

    EXPECT(p == prog);
}

TEST_CASE(pad_reflect_multiaxis_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1875
1876
1877
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3}});
    mm->add_literal({migraphx::shape{migraphx::shape::int32_type, {4}}, {0, 2, 2, 0}});
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
    auto l1 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {0, 1}}, {"ends", {2, 2}}}), l0);
    auto l2 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {0, 2}}, {"ends", {2, 3}}}), l0);
    auto l3 = mm->add_instruction(migraphx::make_op("concat", {{"axis", 1}}), l2, l1, l0);
    auto l4 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {0, 0}}, {"ends", {1, 5}}}), l3);
    auto l5 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {1, 0}}, {"ends", {2, 5}}}), l3);
    auto r = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), l3, l4, l5);
Shucai Xiao's avatar
Shucai Xiao committed
1888
    mm->add_return({r});
kahmed10's avatar
kahmed10 committed
1889
1890
1891
1892
1893
1894

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1895
TEST_CASE(pow_test)
1896
1897
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1898
1899
1900
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
1901
    mm->add_instruction(migraphx::make_op("pow"), l0, l1);
1902

Shucai Xiao's avatar
Shucai Xiao committed
1903
    auto prog = optimize_onnx("pow_test.onnx");
1904
1905
1906
1907

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
TEST_CASE(pow_fp32_i64_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::int64_type, {2, 3, 4, 5}});
    auto l1f = mm->add_instruction(
        migraphx::make_op("convert", {{"target_type", migraphx::shape::float_type}}), l1);
    auto ret = mm->add_instruction(migraphx::make_op("pow"), l0, l1f);
    mm->add_return({ret});

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

    EXPECT(p == prog);
}

TEST_CASE(pow_i64_fp32_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::int64_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l0f = mm->add_instruction(
        migraphx::make_op("convert", {{"target_type", migraphx::shape::float_type}}), l0);
    auto fr = mm->add_instruction(migraphx::make_op("pow"), l0f, l1);
    auto ir = mm->add_instruction(
        migraphx::make_op("convert", {{"target_type", migraphx::shape::int64_type}}), fr);
    mm->add_return({ir});

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1942
1943
1944
TEST_CASE(prelu_brcst_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1945
1946
1947
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 5}});
1948
1949
1950
    auto bl1 = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", l0->get_shape().lens()}}), l1);
    auto ret = mm->add_instruction(migraphx::make_op("prelu"), l0, bl1);
Shucai Xiao's avatar
Shucai Xiao committed
1951
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1952
1953
1954
1955
1956
1957

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1958
1959
1960
TEST_CASE(range_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1961
1962
1963
1964
1965
    auto* mm = p.get_main_module();
    mm->add_literal(int64_t{10});
    mm->add_literal(int64_t{6});
    mm->add_literal(int64_t{-3});
    mm->add_literal(migraphx::literal{{migraphx::shape::int64_type, {2}}, {10, 7}});
kahmed10's avatar
kahmed10 committed
1966
1967
1968
1969
1970
1971
1972
1973
1974

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

    EXPECT(p == prog);
}

TEST_CASE(range_float_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1975
1976
1977
1978
1979
    auto* mm = p.get_main_module();
    mm->add_literal(float{2});
    mm->add_literal(float{11});
    mm->add_literal(float{2});
    mm->add_literal(migraphx::literal{{migraphx::shape::float_type, {5}}, {2, 4, 6, 8, 10}});
kahmed10's avatar
kahmed10 committed
1980
1981
1982
1983
1984
1985

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1986
1987
1988
TEST_CASE(recip_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1989
1990
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3}});
1991
    mm->add_instruction(migraphx::make_op("recip"), input);
kahmed10's avatar
kahmed10 committed
1992
1993
1994
1995
1996
1997

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1998
1999
2000
TEST_CASE(reducel1_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2001
2002
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2003
2004
2005
    auto abs_l0 = mm->add_instruction(migraphx::make_op("abs"), l0);
    auto sum_l0 = mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {-2}}}), abs_l0);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {-2}}}), sum_l0);
Shucai Xiao's avatar
Shucai Xiao committed
2006
2007
2008
2009
2010
2011
2012
2013
    auto prog = optimize_onnx("reducel1_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(reducel2_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2014
2015
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2016
2017
2018
2019
    auto square_l0 = mm->add_instruction(migraphx::make_op("mul"), l0, l0);
    auto sum_l0 = mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {-1}}}), square_l0);
    auto squ_l0 = mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {-1}}}), sum_l0);
    mm->add_instruction(migraphx::make_op("sqrt"), squ_l0);
Shucai Xiao's avatar
Shucai Xiao committed
2020
2021
2022
2023
2024
2025
2026
2027
    auto prog = optimize_onnx("reducel2_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(reduce_log_sum_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2028
2029
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2030
2031
    auto sum_l0 = mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {-3}}}), l0);
    mm->add_instruction(migraphx::make_op("log"), sum_l0);
Shucai Xiao's avatar
Shucai Xiao committed
2032
2033
2034
2035
2036
2037
2038
2039
    auto prog = optimize_onnx("reduce_log_sum_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(reduce_log_sum_exp_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2040
2041
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2042
2043
2044
    auto exp_l0 = mm->add_instruction(migraphx::make_op("exp"), l0);
    auto sum_l0 = mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {-4}}}), exp_l0);
    mm->add_instruction(migraphx::make_op("log"), sum_l0);
Shucai Xiao's avatar
Shucai Xiao committed
2045
2046
2047
2048
2049
    auto prog = optimize_onnx("reduce_log_sum_exp_test.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2050
2051
2052
TEST_CASE(reducemax_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2053
2054
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2055
    mm->add_instruction(migraphx::make_op("reduce_max", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2056
    auto prog = optimize_onnx("reducemax_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2057
2058
2059
2060

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2061
TEST_CASE(reducemean_test)
2062
2063
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2064
2065
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2066
2067
    auto l1  = mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2, 3}}}), l0);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {2, 3}}}), l1);
Shucai Xiao's avatar
Shucai Xiao committed
2068
    auto prog = optimize_onnx("reducemean_test.onnx");
2069
2070
2071
2072

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2073
TEST_CASE(reducemean_keepdims_test)
2074
2075
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2076
2077
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2078
    mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2079
    auto prog = optimize_onnx("reducemean_keepdims_test.onnx");
2080
2081
2082
2083

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2084
2085
2086
TEST_CASE(reducemin_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2087
2088
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2089
2090
    auto l1  = mm->add_instruction(migraphx::make_op("reduce_min", {{"axes", {2, 3}}}), l0);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {2, 3}}}), l1);
Shucai Xiao's avatar
Shucai Xiao committed
2091
    auto prog = optimize_onnx("reducemin_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2092
2093
2094
2095

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2096
2097
2098
TEST_CASE(reduceprod_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2099
2100
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2101
    mm->add_instruction(migraphx::make_op("reduce_prod", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2102
2103
2104
2105
2106
    auto prog = optimize_onnx("reduceprod_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2107
TEST_CASE(reducesum_test)
Khalique's avatar
Khalique committed
2108
2109
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2110
2111
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2112
2113
    auto l1  = mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {2}}}), l0);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {2}}}), l1);
Shucai Xiao's avatar
Shucai Xiao committed
2114
    auto prog = optimize_onnx("reducesum_test.onnx");
2115
2116

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

Khalique's avatar
Khalique committed
2119
TEST_CASE(reducesum_multiaxis_test)
Khalique's avatar
Khalique committed
2120
2121
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2122
2123
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2124
2125
    auto l1  = mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {2, 3}}}), l0);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {2, 3}}}), l1);
Shucai Xiao's avatar
Shucai Xiao committed
2126
    auto prog = optimize_onnx("reducesum_multiaxis_test.onnx");
2127
2128

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

Khalique's avatar
Khalique committed
2131
TEST_CASE(reducesum_keepdims_test)
Khalique's avatar
Khalique committed
2132
2133
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2134
2135
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2136
    mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {2, 3}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2137
    auto prog = optimize_onnx("reducesum_keepdims_test.onnx");
2138
2139
2140
2141

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2142
2143
2144
TEST_CASE(reducesum_square_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2145
2146
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2147
2148
2149
    auto squ_l0 = mm->add_instruction(migraphx::make_op("mul"), l0, l0);
    auto sum_l0 = mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {-2}}}), squ_l0);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {-2}}}), sum_l0);
Shucai Xiao's avatar
Shucai Xiao committed
2150
2151
2152
2153
2154
    auto prog = optimize_onnx("reducesum_square_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2155
TEST_CASE(reshape_test)
2156
{
Khalique's avatar
Khalique committed
2157
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2158
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2159
2160
    migraphx::op::reshape op;
    std::vector<int64_t> reshape_dims{3, 8};
Shucai Xiao's avatar
Shucai Xiao committed
2161
    mm->add_literal(
Khalique's avatar
Khalique committed
2162
        migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, reshape_dims});
Shucai Xiao's avatar
Shucai Xiao committed
2163
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {4, 2, 3}});
Khalique's avatar
Khalique committed
2164
    op.dims = reshape_dims;
Shucai Xiao's avatar
Shucai Xiao committed
2165
2166
    mm->add_instruction(op, l0);
    mm->add_instruction(op, l0);
Shucai Xiao's avatar
Shucai Xiao committed
2167
    auto prog = optimize_onnx("reshape_test.onnx");
2168
2169

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

Khalique's avatar
Khalique committed
2172
TEST_CASE(reshape_non_standard_test)
2173
2174
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2175
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2176
2177
2178
    migraphx::op::reshape op;
    std::vector<int64_t> reshape_dims{4, 3, 2};
    migraphx::shape s{migraphx::shape::float_type, {2, 3, 4}};
Shucai Xiao's avatar
Shucai Xiao committed
2179
    auto x      = mm->add_parameter("x", s);
2180
2181
2182
    auto tran_x = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 2, 1}}}), x);
    auto cont_x = mm->add_instruction(migraphx::make_op("contiguous"), tran_x);
    mm->add_instruction(migraphx::make_op("reshape", {{"dims", {4, 3, 2}}}), cont_x);
Shucai Xiao's avatar
Shucai Xiao committed
2183
    auto prog = optimize_onnx("reshape_non_standard_test.onnx");
2184
2185
2186
2187

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2188
2189
2190
TEST_CASE(resize_downsample_f_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2191
    auto* mm              = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2192
2193
    std::vector<float> ds = {1.0f, 1.0f, 0.6f, 0.6f};
    migraphx::shape ss{migraphx::shape::float_type, {4}};
2194
    mm->add_literal(migraphx::literal{ss, ds});
Shucai Xiao's avatar
Shucai Xiao committed
2195
2196

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 4}};
2197
    auto inx = mm->add_parameter("X", sx);
Shucai Xiao's avatar
Shucai Xiao committed
2198

2199
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2200
2201
2202

    migraphx::shape si{migraphx::shape::int32_type, {1, 1, 1, 2}};
    std::vector<int> ind = {4, 7};
2203
    auto li              = mm->add_literal(migraphx::literal(si, ind));
Shucai Xiao's avatar
Shucai Xiao committed
2204

2205
2206
    auto lrsp = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {8}}}), inx);
    auto r    = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), lrsp, li);
2207
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2208
2209
2210
2211
2212
2213
2214
2215
2216

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

    EXPECT(p == prog);
}

TEST_CASE(resize_downsample_c_test)
{
    migraphx::program p;
2217
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2218
2219
2220

    std::vector<float> ds = {1.0f, 1.0f, 0.6f, 0.6f};
    migraphx::shape ss{migraphx::shape::float_type, {4}};
2221
    mm->add_literal(migraphx::literal{ss, ds});
Shucai Xiao's avatar
Shucai Xiao committed
2222
2223

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 4}};
2224
    auto inx = mm->add_parameter("X", sx);
Shucai Xiao's avatar
Shucai Xiao committed
2225

2226
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2227
2228
2229

    migraphx::shape si{migraphx::shape::int32_type, {1, 1, 1, 2}};
    std::vector<int> ind = {0, 2};
2230
    auto li              = mm->add_literal(migraphx::literal(si, ind));
Shucai Xiao's avatar
Shucai Xiao committed
2231

2232
2233
    auto lrsp = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {8}}}), inx);
    auto r    = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), lrsp, li);
2234
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2235
2236
2237
2238
2239
2240
2241
2242
2243

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

    EXPECT(p == prog);
}

TEST_CASE(resize_outsize_test)
{
    migraphx::program p;
2244
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2245
2246
2247

    std::vector<int64_t> out_len = {1, 1, 4, 6};
    migraphx::shape so{migraphx::shape::int64_type, {4}};
2248
    mm->add_literal(migraphx::literal(so, out_len));
Shucai Xiao's avatar
Shucai Xiao committed
2249
2250

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
2251
    auto inx = mm->add_parameter("X", sx);
Shucai Xiao's avatar
Shucai Xiao committed
2252

2253
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2254
2255
2256

    migraphx::shape si{migraphx::shape::int32_type, {1, 1, 4, 6}};
    std::vector<int> ind = {0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 2, 2, 3, 3, 3, 3, 2, 2, 3, 3, 3, 3};
2257
    auto li              = mm->add_literal(migraphx::literal(si, ind));
Shucai Xiao's avatar
Shucai Xiao committed
2258

2259
2260
    auto lrsp = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {4}}}), inx);
    auto r    = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), lrsp, li);
2261
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2262
2263
2264
2265
2266
2267
2268
2269
2270

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

    EXPECT(p == prog);
}

TEST_CASE(resize_upsample_pc_test)
{
    migraphx::program p;
2271
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2272
2273
2274

    std::vector<float> ds = {1.0f, 1.0f, 2.0f, 1.5f};
    migraphx::shape ss{migraphx::shape::float_type, {4}};
2275
    mm->add_literal(migraphx::literal{ss, ds});
Shucai Xiao's avatar
Shucai Xiao committed
2276
2277

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 4}};
2278
    auto inx = mm->add_parameter("X", sx);
Shucai Xiao's avatar
Shucai Xiao committed
2279

2280
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2281
2282
2283

    migraphx::shape si{migraphx::shape::int32_type, {1, 1, 4, 6}};
    std::vector<int> ind = {0, 1, 1, 2, 3, 3, 0, 1, 1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 4, 5, 5, 6, 7, 7};
2284
    auto li              = mm->add_literal(migraphx::literal(si, ind));
Shucai Xiao's avatar
Shucai Xiao committed
2285

2286
2287
    auto lrsp = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {8}}}), inx);
    auto r    = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), lrsp, li);
2288
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2289
2290
2291
2292
2293
2294
2295
2296
2297

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

    EXPECT(p == prog);
}

TEST_CASE(resize_upsample_pf_test)
{
    migraphx::program p;
2298
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2299
2300
2301

    std::vector<float> ds = {1.0f, 1.0f, 2.0f, 3.0f};
    migraphx::shape ss{migraphx::shape::float_type, {4}};
2302
    mm->add_literal(migraphx::literal{ss, ds});
Shucai Xiao's avatar
Shucai Xiao committed
2303
2304

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
2305
    auto inx = mm->add_parameter("X", sx);
Shucai Xiao's avatar
Shucai Xiao committed
2306

2307
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2308
2309
2310

    migraphx::shape si{migraphx::shape::int32_type, {1, 1, 4, 6}};
    std::vector<int> ind = {0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 2, 2, 2, 3, 3, 3};
2311
    auto li              = mm->add_literal(migraphx::literal(si, ind));
Shucai Xiao's avatar
Shucai Xiao committed
2312

2313
2314
    auto lrsp = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {4}}}), inx);
    auto r    = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), lrsp, li);
2315
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2316
2317
2318
2319
2320
2321

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2322
2323
2324
TEST_CASE(round_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2325
2326
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
2327
    mm->add_instruction(migraphx::make_op("round"), input);
Khalique's avatar
Khalique committed
2328

Shucai Xiao's avatar
Shucai Xiao committed
2329
    auto prog = optimize_onnx("round_test.onnx");
Khalique's avatar
Khalique committed
2330
2331
2332
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2333
2334
2335
TEST_CASE(selu_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2336
    auto* mm                      = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2337
2338
    std::vector<std::size_t> lens = {2, 3};
    migraphx::shape s{migraphx::shape::double_type, lens};
Shucai Xiao's avatar
Shucai Xiao committed
2339
    auto x = mm->add_parameter("x", s);
Shucai Xiao's avatar
Shucai Xiao committed
2340
2341

    migraphx::shape ls{migraphx::shape::double_type, {1}};
2342
2343
2344
2345
2346
2347
    auto la = mm->add_literal({ls, {0.3}});
    auto lg = mm->add_literal({ls, {0.25}});
    auto mbla =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", lens}}), la);
    auto mblg =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", lens}}), lg);
Shucai Xiao's avatar
Shucai Xiao committed
2348

2349
2350
    auto sign_x = mm->add_instruction(migraphx::make_op("sign"), x);
    auto exp_x  = mm->add_instruction(migraphx::make_op("exp"), x);
Shucai Xiao's avatar
Shucai Xiao committed
2351

2352
2353
    auto mlax  = mm->add_instruction(migraphx::make_op("mul"), mbla, exp_x);
    auto smlax = mm->add_instruction(migraphx::make_op("sub"), mlax, mbla);
Shucai Xiao's avatar
Shucai Xiao committed
2354

2355
2356
    auto item1 = mm->add_instruction(migraphx::make_op("add"), smlax, x);
    auto item2 = mm->add_instruction(migraphx::make_op("sub"), smlax, x);
Shucai Xiao's avatar
Shucai Xiao committed
2357

2358
2359
2360
    auto sitem2 = mm->add_instruction(migraphx::make_op("mul"), sign_x, item2);
    auto item12 = mm->add_instruction(migraphx::make_op("sub"), item1, sitem2);
    auto r      = mm->add_instruction(migraphx::make_op("mul"), item12, mblg);
Shucai Xiao's avatar
Shucai Xiao committed
2361
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2362
2363
2364
2365
2366
2367

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2368
TEST_CASE(shape_test)
2369
2370
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2371
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2372
    migraphx::shape s{migraphx::shape::float_type, {3, 4, 5, 6}};
Shucai Xiao's avatar
Shucai Xiao committed
2373
    auto l0 = mm->add_parameter("x", s);
Khalique's avatar
Khalique committed
2374
    migraphx::shape s_shape{migraphx::shape::int64_type, {4}};
Shucai Xiao's avatar
Shucai Xiao committed
2375
    mm->add_literal(s_shape, l0->get_shape().lens());
Shucai Xiao's avatar
Shucai Xiao committed
2376
    auto prog = optimize_onnx("shape_test.onnx");
2377
2378
2379
2380

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2381
TEST_CASE(shape_gather_test)
2382
2383
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2384
2385
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {7, 3, 10}});
2386
    migraphx::shape const_shape{migraphx::shape::int32_type, {1}};
Shucai Xiao's avatar
Shucai Xiao committed
2387
    auto l2 = mm->add_literal(migraphx::literal{const_shape, {1}});
Khalique's avatar
Khalique committed
2388
    auto l1 =
Shucai Xiao's avatar
Shucai Xiao committed
2389
        mm->add_literal(migraphx::shape{migraphx::shape::int64_type, {3}}, l0->get_shape().lens());
Khalique's avatar
Khalique committed
2390
    int axis = 0;
2391
    mm->add_instruction(migraphx::make_op("gather", {{"axis", axis}}), l1, l2);
Shucai Xiao's avatar
Shucai Xiao committed
2392
    auto prog = optimize_onnx("shape_gather_test.onnx");
2393
2394
2395
2396

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2397
TEST_CASE(sign_test)
Khalique's avatar
Khalique committed
2398
2399
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2400
2401
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
2402
    mm->add_instruction(migraphx::make_op("sign"), input);
Khalique's avatar
Khalique committed
2403

Shucai Xiao's avatar
Shucai Xiao committed
2404
    auto prog = optimize_onnx("sign_test.onnx");
Khalique's avatar
Khalique committed
2405
2406
2407
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2408
TEST_CASE(sin_test)
2409
2410
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2411
2412
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
2413
    mm->add_instruction(migraphx::make_op("sin"), input);
2414

Shucai Xiao's avatar
Shucai Xiao committed
2415
    auto prog = optimize_onnx("sin_test.onnx");
2416
2417
2418
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2419
TEST_CASE(sinh_test)
2420
2421
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2422
2423
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
2424
    mm->add_instruction(migraphx::make_op("sinh"), input);
Khalique's avatar
Khalique committed
2425

Shucai Xiao's avatar
Shucai Xiao committed
2426
    auto prog = optimize_onnx("sinh_test.onnx");
2427
2428
2429
2430

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
2431
2432
2433
TEST_CASE(slice_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2434
2435
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 2}});
2436
2437
    mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {1, 0}}, {"ends", {2, 2}}}), l0);
kahmed10's avatar
kahmed10 committed
2438
2439
2440
2441
2442
2443
2444
2445
    auto prog = optimize_onnx("slice_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(slice_3arg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2446
2447
2448
2449
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 5}});
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {0, 0}});
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {2, 5}});
2450
2451
    auto ret = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {0, 0}}, {"ends", {2, 5}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2452
    mm->add_return({ret});
kahmed10's avatar
kahmed10 committed
2453
2454
2455
2456
2457
2458

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2459
2460
2461
TEST_CASE(slice_5arg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2462
2463
2464
2465
2466
2467
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 5}});
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {1, 1}});
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {-1, -2}});
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {-1, -1}});
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {-5, -3}});
2468
2469
2470
    auto ret = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {-1, -2}}, {"starts", {-5, -3}}, {"ends", {-1, -1}}}),
        l0);
Shucai Xiao's avatar
Shucai Xiao committed
2471
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
2472
2473
2474
2475
2476
2477

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

    EXPECT(p == prog);
}

2478
2479
2480
TEST_CASE(slice_max_end_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2481
2482
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {10, 20}});
2483
2484
2485
2486
    mm->add_instruction(
        migraphx::make_op("slice",
                          {{"axes", {0, 1}}, {"starts", {1, 2}}, {"ends", {3000000000, -1}}}),
        l0);
2487
2488
2489
2490
2491
    auto prog = optimize_onnx("slice_max_end_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2492
TEST_CASE(softmax_test)
Shucai Xiao's avatar
Shucai Xiao committed
2493
2494
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2495
2496
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
2497
    mm->add_instruction(migraphx::make_op("softmax", {{"axis", 1}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2498
    auto prog = optimize_onnx("softmax_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2499
2500
2501
2502

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2503
2504
2505
TEST_CASE(split_minus_axis_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2506
2507
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2508
2509
2510
2511
2512
2513
    auto r1    = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {-1}}, {"starts", {0}}, {"ends", {5}}}), input);
    auto r2 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {-1}}, {"starts", {5}}, {"ends", {10}}}), input);
    auto r3 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {-1}}, {"starts", {10}}, {"ends", {15}}}), input);
Shucai Xiao's avatar
Shucai Xiao committed
2514
    mm->add_return({r1, r2, r3});
Shucai Xiao's avatar
Shucai Xiao committed
2515
2516
2517
2518
2519
2520

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

    EXPECT(p == prog);
}

2521
2522
2523
TEST_CASE(split_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2524
2525
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2526
2527
2528
2529
2530
2531
    auto r1    = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {1}}, {"starts", {0}}, {"ends", {7}}}), input);
    auto r2 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {1}}, {"starts", {7}}, {"ends", {11}}}), input);
    auto r3 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {1}}, {"starts", {11}}, {"ends", {15}}}), input);
Shucai Xiao's avatar
Shucai Xiao committed
2532
    mm->add_return({r1, r2, r3});
2533
2534
2535
2536
2537
2538
2539
2540

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

TEST_CASE(split_test_default)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2541
2542
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2543
2544
2545
2546
    auto r1    = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {5}}}), input);
    auto r2 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {5}}, {"ends", {10}}}), input);
Shucai Xiao's avatar
Shucai Xiao committed
2547
    mm->add_return({r1, r2});
2548
2549
2550
2551
2552

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

Khalique's avatar
Khalique committed
2553
TEST_CASE(sqrt_test)
Shucai Xiao's avatar
Shucai Xiao committed
2554
2555
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2556
2557
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2558
    mm->add_instruction(migraphx::make_op("sqrt"), input);
Shucai Xiao's avatar
Shucai Xiao committed
2559

Shucai Xiao's avatar
Shucai Xiao committed
2560
    auto prog = optimize_onnx("sqrt_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2561
2562
2563
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2564
TEST_CASE(squeeze_unsqueeze_test)
Khalique's avatar
Khalique committed
2565
2566
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2567
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2568
2569
2570
    std::vector<int64_t> squeeze_axes{0, 2, 3, 5};
    std::vector<int64_t> unsqueeze_axes{0, 1, 3, 5};
    auto l0 =
Shucai Xiao's avatar
Shucai Xiao committed
2571
        mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 1, 1, 2, 1}});
2572
2573
    auto l1 = mm->add_instruction(migraphx::make_op("squeeze", {{"axes", squeeze_axes}}), l0);
    mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", unsqueeze_axes}}), l1);
Shucai Xiao's avatar
Shucai Xiao committed
2574
    auto prog = optimize_onnx("squeeze_unsqueeze_test.onnx");
Khalique's avatar
Khalique committed
2575
2576
2577
2578

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2579
TEST_CASE(sub_bcast_test)
Shucai Xiao's avatar
Shucai Xiao committed
2580
2581
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2582
2583
2584
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}});
2585
2586
2587
    auto l2  = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", 1}, {"dims", l0->get_shape().lens()}}), l1);
    mm->add_instruction(migraphx::make_op("sub"), l0, l2);
Shucai Xiao's avatar
Shucai Xiao committed
2588

Shucai Xiao's avatar
Shucai Xiao committed
2589
    auto prog = optimize_onnx("sub_bcast_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2590
2591
2592
2593

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2594
TEST_CASE(sub_scalar_test)
Shucai Xiao's avatar
Shucai Xiao committed
2595
2596
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2597
2598
2599
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1 = mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::float_type}, {1}});
2600
2601
2602
    auto m1 = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 4, 5}}}), l1);
    mm->add_instruction(migraphx::make_op("sub"), l0, m1);
Shucai Xiao's avatar
Shucai Xiao committed
2603
    auto prog = optimize_onnx("sub_scalar_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2604
2605
2606
2607

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2608
2609
2610
TEST_CASE(sum_int_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2611
2612
2613
2614
    auto* mm    = p.get_main_module();
    auto input0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::int16_type, {3}});
    auto input1 = mm->add_parameter("1", migraphx::shape{migraphx::shape::uint16_type, {3}});
    auto input2 = mm->add_parameter("2", migraphx::shape{migraphx::shape::uint32_type, {3}});
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
    auto cin0   = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::uint32_type)}}),
        input0);
    auto cin1 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::uint32_type)}}),
        input1);
    auto l0 = mm->add_instruction(migraphx::make_op("add"), cin0, cin1);
    mm->add_instruction(migraphx::make_op("add"), l0, input2);
Shucai Xiao's avatar
Shucai Xiao committed
2625
2626
2627
2628
2629

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

Khalique's avatar
Khalique committed
2630
TEST_CASE(sum_test)
2631
2632
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2633
2634
2635
2636
    auto* mm    = p.get_main_module();
    auto input0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input1 = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input2 = mm->add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
2637
2638
    auto l0     = mm->add_instruction(migraphx::make_op("add"), input0, input1);
    mm->add_instruction(migraphx::make_op("add"), l0, input2);
2639

Shucai Xiao's avatar
Shucai Xiao committed
2640
    auto prog = optimize_onnx("sum_test.onnx");
2641
2642
2643
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2644
2645
2646
TEST_CASE(sum_type_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2647
2648
2649
2650
2651
2652
2653
2654
2655
    auto* mm      = p.get_main_module();
    auto l_bool   = mm->add_literal({migraphx::shape{migraphx::shape::bool_type, {2}}, {1, 0}});
    auto l_int8   = mm->add_literal({migraphx::shape{migraphx::shape::int8_type, {2}}, {1, 1}});
    auto l_uint8  = mm->add_literal({migraphx::shape{migraphx::shape::uint8_type, {2}}, {1, 1}});
    auto l_uint16 = mm->add_literal({migraphx::shape{migraphx::shape::uint16_type, {2}}, {1, 1}});
    auto l_uint32 = mm->add_literal({migraphx::shape{migraphx::shape::uint32_type, {2}}, {1, 1}});
    auto l_uint64 = mm->add_literal({migraphx::shape{migraphx::shape::uint64_type, {2}}, {1, 1}});
    auto l_double = mm->add_literal({migraphx::shape{migraphx::shape::double_type, {2}}, {1, 1}});
    auto l_raw  = mm->add_literal({migraphx::shape{migraphx::shape::double_type, {2}}, {1.5, 2.0}});
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
    auto o_bool = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::double_type)}}),
        l_bool);
    auto o_int8 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::double_type)}}),
        l_int8);
    auto o_uint8 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::double_type)}}),
        l_uint8);
    auto o_uint16 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::double_type)}}),
        l_uint16);
    auto o_uint32 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::double_type)}}),
        l_uint32);
    auto o_uint64 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::double_type)}}),
        l_uint64);
    auto s0 = mm->add_instruction(migraphx::make_op("add"), o_bool, o_int8);
    auto s1 = mm->add_instruction(migraphx::make_op("add"), s0, o_uint8);
    auto s2 = mm->add_instruction(migraphx::make_op("add"), s1, o_uint16);
    auto s3 = mm->add_instruction(migraphx::make_op("add"), s2, o_uint32);
    auto s4 = mm->add_instruction(migraphx::make_op("add"), s3, o_uint64);
    auto s5 = mm->add_instruction(migraphx::make_op("add"), s4, l_double);
    auto s6 = mm->add_instruction(migraphx::make_op("add"), s5, l_raw);
Shucai Xiao's avatar
Shucai Xiao committed
2687
    mm->add_return({s6});
Shucai Xiao's avatar
Shucai Xiao committed
2688
2689
2690
2691
2692
2693

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2694
TEST_CASE(tan_test)
2695
2696
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2697
2698
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
2699
    mm->add_instruction(migraphx::make_op("tan"), input);
2700

Shucai Xiao's avatar
Shucai Xiao committed
2701
    auto prog = optimize_onnx("tan_test.onnx");
2702
2703
2704
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2705
TEST_CASE(tanh_test)
2706
2707
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2708
2709
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}});
2710
    mm->add_instruction(migraphx::make_op("tanh"), input);
2711

Shucai Xiao's avatar
Shucai Xiao committed
2712
    auto prog = optimize_onnx("tanh_test.onnx");
2713
2714
2715
2716

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
2717
2718
2719
TEST_CASE(tile_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2720
2721
2722
    auto* mm = p.get_main_module();
    mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, {1, 2}});
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2, 2}});
2723
    mm->add_instruction(migraphx::make_op("concat", {{"axis", 1}}), input, input);
kahmed10's avatar
kahmed10 committed
2724
2725
2726
2727
2728
2729
2730
2731
2732

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

    EXPECT(p == prog);
}

TEST_CASE(tile_test_3x2)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2733
2734
2735
    auto* mm = p.get_main_module();
    mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, {3, 2}});
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2, 2}});
2736
2737
2738
    auto l0    = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), input, input);
    auto l1    = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), l0, input);
    mm->add_instruction(migraphx::make_op("concat", {{"axis", 1}}), l1, l1);
kahmed10's avatar
kahmed10 committed
2739
2740
2741
2742
2743
2744

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2745
TEST_CASE(transpose_test)
2746
2747
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2748
2749
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
Khalique's avatar
Khalique committed
2750
    std::vector<int64_t> perm{0, 3, 1, 2};
2751
    mm->add_instruction(migraphx::make_op("transpose", {{"dims", perm}}), input);
Khalique's avatar
Khalique committed
2752

Shucai Xiao's avatar
Shucai Xiao committed
2753
    auto prog = optimize_onnx("transpose_test.onnx");
2754
2755
2756
2757

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2758
TEST_CASE(transpose_gather_test)
2759
2760
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2761
2762
    auto* mm             = p.get_main_module();
    auto make_contiguous = [&mm](migraphx::instruction_ref ins) {
Khalique's avatar
Khalique committed
2763
2764
2765
2766
2767
        if(ins->get_shape().standard())
        {
            return ins;
        }

2768
        return mm->add_instruction(migraphx::make_op("contiguous"), ins);
Khalique's avatar
Khalique committed
2769
2770
    };

Shucai Xiao's avatar
Shucai Xiao committed
2771
2772
    auto data =
        mm->add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 5, 4, 6}});
Khalique's avatar
Khalique committed
2773
    auto ind =
Shucai Xiao's avatar
Shucai Xiao committed
2774
        mm->add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 4, 3, 5}});
2775
2776
2777
2778
2779
2780
2781
2782
    auto tr_data =
        mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 2, 1, 3}}}), data);
    auto tr_ind =
        mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 2, 1, 3}}}), ind);
    int axis = 1;
    mm->add_instruction(migraphx::make_op("gather", {{"axis", axis}}),
                        make_contiguous(tr_data),
                        make_contiguous(tr_ind));
Khalique's avatar
Khalique committed
2783

Shucai Xiao's avatar
Shucai Xiao committed
2784
    auto prog = optimize_onnx("transpose_gather_test.onnx");
2785

2786
    EXPECT(p.sort() == prog.sort());
2787
2788
}

2789
2790
2791
TEST_CASE(undefined_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2792
2793
    auto* mm = p.get_main_module();
    mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
2794
2795
    auto l1 = mm->add_instruction(migraphx::make_op("undefined"));
    auto l2 = mm->add_instruction(migraphx::make_op("identity"), l1);
Shucai Xiao's avatar
Shucai Xiao committed
2796
    mm->add_return({l2});
2797
2798
2799
2800
2801
2802

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2803
TEST_CASE(unknown_test)
2804
2805
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2806
2807
2808
2809
2810
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}});
    auto l2  = mm->add_instruction(migraphx::op::unknown{"Unknown"}, l0, l1);
    mm->add_instruction(migraphx::op::unknown{"Unknown"}, l2);
Shucai Xiao's avatar
Shucai Xiao committed
2811
    auto prog = optimize_onnx("unknown_test.onnx");
2812
2813
2814
2815

    EXPECT(p == prog);
}

2816
2817
2818
2819
2820
TEST_CASE(unknown_aten_test)
{
    EXPECT(test::throws([&] { migraphx::parse_onnx("unknown_aten_test.onnx"); }));
}

2821
2822
2823
2824
2825
TEST_CASE(unknown_test_throw)
{
    EXPECT(test::throws([&] { migraphx::parse_onnx("unknown_test.onnx"); }));
}

Shucai Xiao's avatar
Shucai Xiao committed
2826
2827
2828
TEST_CASE(upsample_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2829
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2830
    migraphx::shape ss{migraphx::shape::float_type, {4}};
Shucai Xiao's avatar
Shucai Xiao committed
2831
    mm->add_literal(migraphx::literal(ss, {1.0f, 1.0f, 2.0f, 3.0f}));
Shucai Xiao's avatar
Shucai Xiao committed
2832
2833

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
Shucai Xiao's avatar
Shucai Xiao committed
2834
    auto ix = mm->add_parameter("X", sx);
Shucai Xiao's avatar
Shucai Xiao committed
2835
2836
2837
2838

    migraphx::shape si{migraphx::shape::int32_type, {1, 1, 4, 6}};
    std::vector<int> ind = {0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 2, 2, 2, 3, 3, 3};

Shucai Xiao's avatar
Shucai Xiao committed
2839
    auto li  = mm->add_literal(migraphx::literal(si, ind));
2840
2841
    auto rsp = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {4}}}), ix);
    auto r   = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), rsp, li);
Shucai Xiao's avatar
Shucai Xiao committed
2842
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2843
2844
2845
2846
2847
2848

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

    EXPECT(p == prog);
}

2849
2850
2851
2852
2853
2854
2855
TEST_CASE(unknown_test_throw_print_error)
{
    migraphx::onnx_options options;
    options.print_program_on_error = true;
    EXPECT(test::throws([&] { migraphx::parse_onnx("unknown_test.onnx", options); }));
}

2856
2857
2858
TEST_CASE(variable_batch_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2859
2860
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
2861
    mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2862
    auto prog = optimize_onnx("variable_batch_test.onnx");
2863
2864
2865
2866

    EXPECT(p == prog);
}

2867
2868
2869
TEST_CASE(variable_batch_user_input_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2870
2871
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 16, 16}});
2872
    auto r   = mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2873
    mm->add_return({r});
2874
2875
2876
2877
2878
2879
2880
2881
2882

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

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

    EXPECT(p == prog);
}

2883
2884
2885
TEST_CASE(variable_batch_leq_zero_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2886
2887
2888
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
2889
    mm->add_instruction(migraphx::make_op("add"), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
2890
    auto prog = optimize_onnx("variable_batch_leq_zero_test.onnx");
2891
2892
2893
2894

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2895
2896
2897
TEST_CASE(where_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2898
2899
2900
2901
2902
    auto* mm = p.get_main_module();
    auto lc  = mm->add_parameter("c", migraphx::shape{migraphx::shape::bool_type, {2}});
    auto lx  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2, 2, 2}});
    auto ly  = mm->add_parameter("y", migraphx::shape{migraphx::shape::float_type, {2, 1, 2, 2}});

2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
    auto int_c = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int32_type)}}),
        lc);
    auto lccm = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {2, 2, 2, 2}}}), int_c);
    auto lxm = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {2, 2, 2, 2}}}), lx);
    auto lym = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", {2, 2, 2, 2}}}), ly);

    auto concat_data = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), lym, lxm);
    auto rsp_data =
        mm->add_instruction(migraphx::make_op("reshape", {{"dims", {32}}}), concat_data);
Shucai Xiao's avatar
Shucai Xiao committed
2917
2918
2919
2920
2921
2922
2923
2924
2925

    std::vector<int> offset(16, 16);
    std::vector<int> ind(16);
    std::iota(ind.begin(), ind.end(), 0);
    migraphx::shape ind_s{migraphx::shape::int32_type, {2, 2, 2, 2}};

    auto lind    = mm->add_literal(migraphx::literal(ind_s, ind));
    auto loffset = mm->add_literal(migraphx::literal(ind_s, offset));

2926
2927
2928
    auto ins_co  = mm->add_instruction(migraphx::make_op("mul"), loffset, lccm);
    auto ins_ind = mm->add_instruction(migraphx::make_op("add"), ins_co, lind);
    auto r = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), rsp_data, ins_ind);
Shucai Xiao's avatar
Shucai Xiao committed
2929
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2930
2931
2932
2933
2934
2935

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

    EXPECT(p == prog);
}

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