onnx_test.cpp 105 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
1034
1035
1036
1037
1038
1039
1040
migraphx::program create_external_data_prog()
{
    migraphx::program p;
    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);
    auto bias    = p.add_literal(migraphx::literal({migraphx::shape::float_type, {10}}, bias_data));
    auto weights = p.add_literal(migraphx::literal(s2, weight_data));
    auto param   = p.add_parameter("input", s);
1041
1042
1043
1044
    auto conv    = p.add_instruction(migraphx::make_op("convolution"), param, weights);
    auto bias_bcast = p.add_instruction(
        migraphx::make_op("broadcast", {{"axis", 1}, {"dims", {1, 10, 214, 214}}}), bias);
    p.add_instruction(migraphx::make_op("add"), conv, bias_bcast);
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
    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
1064
TEST_CASE(flatten_test)
1065
1066
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1067
1068
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
1069
1070
    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
1071
    auto prog = optimize_onnx("flatten_test.onnx");
1072
1073
1074
1075

    EXPECT(p == prog);
}

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

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1088
TEST_CASE(gather_test)
1089
1090
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1091
1092
1093
    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
1094
    int axis = 1;
1095
    mm->add_instruction(migraphx::make_op("gather", {{"axis", axis}}), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1096
    auto prog = optimize_onnx("gather_test.onnx");
1097
1098
1099
1100

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1101
1102
1103
TEST_CASE(gather_elements_axis0_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1104
1105
1106
    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
1107
1108
1109
1110
    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
1111
        mm->add_literal(migraphx::literal{ind_s, ind_indices.begin(), ind_indices.end()});
Shucai Xiao's avatar
Shucai Xiao committed
1112
    auto l_ind_axis_indices =
Shucai Xiao's avatar
Shucai Xiao committed
1113
1114
        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
1115

1116
1117
1118
1119
1120
1121
1122
    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
1123
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1124
1125
1126
1127
1128
1129
1130
1131
1132

    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
1133
1134
1135
    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
1136
1137
1138
1139
    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
1140
        mm->add_literal(migraphx::literal{ind_s, ind_indices.begin(), ind_indices.end()});
Shucai Xiao's avatar
Shucai Xiao committed
1141
    auto l_ind_axis_indices =
Shucai Xiao's avatar
Shucai Xiao committed
1142
1143
        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
1144

1145
1146
1147
1148
1149
1150
1151
    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
1152
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1153
1154
1155
1156
1157
1158

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1159
TEST_CASE(gemm_test)
1160
1161
{
    migraphx::program p;
1162
1163
1164
1165
1166
1167
1168
1169
    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
1170
1171
    auto alpha = 2.f;
    auto beta  = 2.0f;
1172
    mm->add_instruction(migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), t0, t1, bl2);
Shucai Xiao's avatar
Shucai Xiao committed
1173
    auto prog = optimize_onnx("gemm_test.onnx");
1174
1175
1176
1177

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1213
TEST_CASE(globalavgpool_test)
1214
1215
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1216
1217
1218
    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
1219
1220
1221
    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
1222
    mm->add_instruction(op, input);
Khalique's avatar
Khalique committed
1223

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1229
TEST_CASE(globalmaxpool_test)
Khalique's avatar
Khalique committed
1230
1231
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1232
1233
1234
    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
1235
1236
1237
    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
1238
    mm->add_instruction(op, input);
Khalique's avatar
Khalique committed
1239

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

    EXPECT(p == prog);
}

1245
1246
1247
TEST_CASE(greater_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1248
    auto* mm = p.get_main_module();
1249
1250
1251
    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
1252
1253
    auto input1 = mm->add_literal(migraphx::literal(s, data));
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
1254
1255
1256
1257
1258
    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
1259
    mm->add_return({ret});
1260
1261
1262
1263
1264
1265
1266
1267

    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
1268
    auto* mm = p.get_main_module();
1269
1270
1271
    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
1272
1273
    auto input1 = mm->add_parameter("x1", sf);
    auto input2 = mm->add_parameter("x2", sb);
1274
1275
1276
1277
1278
    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
1279
    mm->add_return({ret});
1280
1281
1282
1283
1284

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

Khalique's avatar
Khalique committed
1285
TEST_CASE(group_conv_test)
1286
1287
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1288
1289
1290
    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
1291
1292
    migraphx::op::convolution op;
    op.group = 4;
Shucai Xiao's avatar
Shucai Xiao committed
1293
    mm->add_instruction(op, l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1294
    auto prog = optimize_onnx("group_conv_test.onnx");
1295
1296
1297
1298

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1299
TEST_CASE(imagescaler_test)
1300
1301
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1302
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
1303
    migraphx::shape s{migraphx::shape::float_type, {1, 3, 16, 16}};
Shucai Xiao's avatar
Shucai Xiao committed
1304
1305
1306
    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
1307
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
1308
1309
1310
1311
1312
1313
    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
1314

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1320
1321
1322
TEST_CASE(imagescaler_half_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1323
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1324
    migraphx::shape s{migraphx::shape::half_type, {1, 3, 16, 16}};
Shucai Xiao's avatar
Shucai Xiao committed
1325
    auto l0 = mm->add_parameter("0", s);
Shucai Xiao's avatar
Shucai Xiao committed
1326
    auto scale_val =
Shucai Xiao's avatar
Shucai Xiao committed
1327
1328
        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
1329
        migraphx::literal{migraphx::shape{migraphx::shape::half_type, {3}}, {0.01, 0.02, 0.03}});
1330
1331
1332
1333
1334
1335
    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
1336
1337
1338
1339
1340
1341

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1342
TEST_CASE(implicit_add_bcast_test)
1343
1344
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1345
1346
1347
    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}});
1348
1349
1350
    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
1351

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

    EXPECT(p == prog);
}

1357
1358
1359
TEST_CASE(implicit_add_bcast_user_input_shape_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1360
1361
1362
    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}});
1363
1364
1365
    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
1366
    mm->add_return({r});
1367
1368
1369
1370
1371
1372
1373
1374
1375

    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
1376
TEST_CASE(implicit_pow_bcast_test)
1377
1378
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1379
1380
1381
    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}});
1382
1383
1384
    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
1385

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1391
TEST_CASE(implicit_sub_bcast_test)
1392
1393
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1394
1395
1396
    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}});
1397
1398
1399
    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
1400

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

    EXPECT(p == prog);
}

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

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

    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
1427
1428
1429
1430
1431
    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);

1432
1433
1434
1435
1436
1437
    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
1438
    auto epsilon_literal = mm->add_literal(1e-5f);
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
    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
1452
1453

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

    EXPECT(p == prog);
}

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

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

    EXPECT(p == prog);
}

1471
1472
1473
TEST_CASE(less_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1474
    auto* mm = p.get_main_module();
1475
1476
1477
    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
1478
1479
    auto input1 = mm->add_literal(migraphx::literal(s, data));
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
1480
1481
1482
1483
1484
    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
1485
    mm->add_return({ret});
1486
1487
1488
1489
1490
1491
1492
1493

    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
1494
    auto* mm = p.get_main_module();
1495
1496
1497
    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
1498
1499
    auto input1 = mm->add_parameter("x1", sf);
    auto input2 = mm->add_parameter("x2", sb);
1500
1501
1502
1503
1504
    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
1505
    mm->add_return({ret});
1506
1507
1508
1509
1510

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

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

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

Khalique's avatar
Khalique committed
1522
TEST_CASE(logsoftmax_test)
1523
1524
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1525
1526
    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
1527
    int axis = 1;
1528
    mm->add_instruction(migraphx::make_op("logsoftmax", {{"axis", axis}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
1529
    auto prog = optimize_onnx("logsoftmax_test.onnx");
1530
1531
1532
1533

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1534
TEST_CASE(lrn_test)
1535
1536
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1537
1538
    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
1539
1540
1541
1542
1543
    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
1544
    mm->add_instruction(op, l0);
Shucai Xiao's avatar
Shucai Xiao committed
1545
    auto prog = optimize_onnx("lrn_test.onnx");
1546
1547
1548
1549

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1550
TEST_CASE(matmul_bmbm_test)
1551
1552
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1553
1554
1555
    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}});
1556
1557
1558
1559
1560
    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
1561

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1567
TEST_CASE(matmul_bmv_test)
1568
{
Khalique's avatar
Khalique committed
1569
    migraphx::program p;
1570
1571
1572
1573
1574
1575
1576
1577
1578
    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);
1579

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

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

Khalique's avatar
Khalique committed
1585
TEST_CASE(matmul_mv_test)
1586
1587
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1588
1589
1590
    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}});
1591
1592
1593
1594
    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
1595

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1601
TEST_CASE(matmul_vbm_test)
1602
1603
{
    migraphx::program p;
1604
1605
1606
1607
1608
1609
1610
1611
1612
    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
1613

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1619
TEST_CASE(matmul_vm_test)
1620
1621
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1622
1623
1624
    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}});
1625
1626
1627
1628
    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
1629

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1635
TEST_CASE(matmul_vv_test)
1636
1637
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1638
1639
1640
    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}});
1641
1642
1643
1644
1645
1646
    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);
1647

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

    EXPECT(p == prog);
}

1653
1654
1655
TEST_CASE(matmulinteger_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1656
1657
1658
    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}});
1659
    mm->add_instruction(migraphx::make_op("quant_dot", {{"alpha", 1}, {"beta", 0}}), l0, l1);
1660
1661
1662
1663
1664
1665

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1666
TEST_CASE(max_test)
1667
1668
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1669
1670
1671
1672
    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}});
1673
1674
    auto l0     = mm->add_instruction(migraphx::make_op("max"), input0, input1);
    mm->add_instruction(migraphx::make_op("max"), l0, input2);
1675

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

1679
1680
1681
TEST_CASE(maxpool_notset_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1682
1683
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
1684
1685
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
    float val                 = std::numeric_limits<float>::lowest();
1686
1687
1688
1689
1690
1691
1692
    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);
1693
1694
1695
1696
1697
1698
1699
1700
1701

    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
1702
1703
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
1704
1705
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
    float val                 = std::numeric_limits<float>::lowest();
1706
1707
1708
1709
1710
1711
1712
    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);
1713
1714
1715
1716
1717
1718

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1719
1720
1721
TEST_CASE(min_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1722
1723
1724
1725
    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}});
1726
1727
    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
1728

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

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

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

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

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

    EXPECT(p == prog);
}

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

    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
1767
1768
    auto r                       = mm->add_literal(migraphx::literal(si, indices));
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1769
1770
1771
1772
1773
1774
1775
1776

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

    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
1784
1785
    auto r                       = mm->add_literal(migraphx::literal(si, indices));
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1786
1787
1788
1789
1790

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

kahmed10's avatar
kahmed10 committed
1791
1792
1793
TEST_CASE(onehot_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1794
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1795
1796
    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
1797
1798
1799
    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
1800
1801
    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
1802
    auto l_dep      = mm->add_literal(migraphx::literal(s_dep, data_dep));
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
    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
1817
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1818
1819

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

    EXPECT(p == prog);
}

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

    EXPECT(p == prog);
}

1835
1836
1837
TEST_CASE(pad_3arg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1838
1839
1840
1841
    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}});
1842
1843
    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
1844
    mm->add_return({r});
1845
1846
1847
1848
1849
1850

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1851
1852
1853
TEST_CASE(pad_reflect_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1854
1855
1856
    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}});
1857
1858
1859
1860
1861
1862
1863
    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
1864
    mm->add_return({r});
kahmed10's avatar
kahmed10 committed
1865
1866
1867
1868
1869
1870
1871
1872
1873

    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
1874
1875
1876
    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}});
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
    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
1887
    mm->add_return({r});
kahmed10's avatar
kahmed10 committed
1888
1889
1890
1891
1892
1893

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1894
TEST_CASE(pow_test)
1895
1896
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1897
1898
1899
    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}});
1900
    mm->add_instruction(migraphx::make_op("pow"), l0, l1);
1901

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1907
1908
1909
TEST_CASE(prelu_brcst_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1910
1911
1912
    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}});
1913
1914
1915
    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
1916
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1917
1918
1919
1920
1921
1922

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1923
1924
1925
TEST_CASE(range_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1926
1927
1928
1929
1930
    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
1931
1932
1933
1934
1935
1936
1937
1938
1939

    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
1940
1941
1942
1943
1944
    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
1945
1946
1947
1948
1949
1950

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1951
1952
1953
TEST_CASE(recip_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1954
1955
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3}});
1956
    mm->add_instruction(migraphx::make_op("recip"), input);
kahmed10's avatar
kahmed10 committed
1957
1958
1959
1960
1961
1962

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1963
1964
1965
TEST_CASE(reducel1_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1966
1967
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
1968
1969
1970
    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
1971
1972
1973
1974
1975
1976
1977
1978
    auto prog = optimize_onnx("reducel1_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(reducel2_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1979
1980
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
1981
1982
1983
1984
    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
1985
1986
1987
1988
1989
1990
1991
1992
    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
1993
1994
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
1995
1996
    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
1997
1998
1999
2000
2001
2002
2003
2004
    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
2005
2006
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2007
2008
2009
    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
2010
2011
2012
2013
2014
    auto prog = optimize_onnx("reduce_log_sum_exp_test.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2015
2016
2017
TEST_CASE(reducemax_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2018
2019
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2020
    mm->add_instruction(migraphx::make_op("reduce_max", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2021
    auto prog = optimize_onnx("reducemax_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2022
2023
2024
2025

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2026
TEST_CASE(reducemean_test)
2027
2028
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2029
2030
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2031
2032
    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
2033
    auto prog = optimize_onnx("reducemean_test.onnx");
2034
2035
2036
2037

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2038
TEST_CASE(reducemean_keepdims_test)
2039
2040
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2041
2042
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2043
    mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2044
    auto prog = optimize_onnx("reducemean_keepdims_test.onnx");
2045
2046
2047
2048

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2049
2050
2051
TEST_CASE(reducemin_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2052
2053
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2054
2055
    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
2056
    auto prog = optimize_onnx("reducemin_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2057
2058
2059
2060

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2061
2062
2063
TEST_CASE(reduceprod_test)
{
    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
    mm->add_instruction(migraphx::make_op("reduce_prod", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2067
2068
2069
2070
2071
    auto prog = optimize_onnx("reduceprod_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2072
TEST_CASE(reducesum_test)
Khalique's avatar
Khalique committed
2073
2074
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2075
2076
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2077
2078
    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
2079
    auto prog = optimize_onnx("reducesum_test.onnx");
2080
2081

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

Khalique's avatar
Khalique committed
2084
TEST_CASE(reducesum_multiaxis_test)
Khalique's avatar
Khalique committed
2085
2086
{
    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_sum", {{"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("reducesum_multiaxis_test.onnx");
2092
2093

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

Khalique's avatar
Khalique committed
2096
TEST_CASE(reducesum_keepdims_test)
Khalique's avatar
Khalique committed
2097
2098
{
    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_sum", {{"axes", {2, 3}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2102
    auto prog = optimize_onnx("reducesum_keepdims_test.onnx");
2103
2104
2105
2106

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2107
2108
2109
TEST_CASE(reducesum_square_test)
{
    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
2114
    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
2115
2116
2117
2118
2119
    auto prog = optimize_onnx("reducesum_square_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2120
TEST_CASE(reshape_test)
2121
{
Khalique's avatar
Khalique committed
2122
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2123
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2124
2125
    migraphx::op::reshape op;
    std::vector<int64_t> reshape_dims{3, 8};
Shucai Xiao's avatar
Shucai Xiao committed
2126
    mm->add_literal(
Khalique's avatar
Khalique committed
2127
        migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, reshape_dims});
Shucai Xiao's avatar
Shucai Xiao committed
2128
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {4, 2, 3}});
Khalique's avatar
Khalique committed
2129
    op.dims = reshape_dims;
Shucai Xiao's avatar
Shucai Xiao committed
2130
2131
    mm->add_instruction(op, l0);
    mm->add_instruction(op, l0);
Shucai Xiao's avatar
Shucai Xiao committed
2132
    auto prog = optimize_onnx("reshape_test.onnx");
2133
2134

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

Khalique's avatar
Khalique committed
2137
TEST_CASE(reshape_non_standard_test)
2138
2139
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2140
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2141
2142
2143
    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
2144
    auto x      = mm->add_parameter("x", s);
2145
2146
2147
    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
2148
    auto prog = optimize_onnx("reshape_non_standard_test.onnx");
2149
2150
2151
2152

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2153
2154
2155
TEST_CASE(resize_downsample_f_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2156
    auto* mm              = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2157
2158
    std::vector<float> ds = {1.0f, 1.0f, 0.6f, 0.6f};
    migraphx::shape ss{migraphx::shape::float_type, {4}};
2159
    mm->add_literal(migraphx::literal{ss, ds});
Shucai Xiao's avatar
Shucai Xiao committed
2160
2161

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

2164
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2165
2166
2167

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

2170
2171
    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);
2172
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2173
2174
2175
2176
2177
2178
2179
2180
2181

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

    EXPECT(p == prog);
}

TEST_CASE(resize_downsample_c_test)
{
    migraphx::program p;
2182
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2183
2184
2185

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

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

2191
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2192
2193
2194

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

2197
2198
    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);
2199
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2200
2201
2202
2203
2204
2205
2206
2207
2208

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

    EXPECT(p == prog);
}

TEST_CASE(resize_outsize_test)
{
    migraphx::program p;
2209
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2210
2211
2212

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

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

2218
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2219
2220
2221

    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};
2222
    auto li              = mm->add_literal(migraphx::literal(si, ind));
Shucai Xiao's avatar
Shucai Xiao committed
2223

2224
2225
    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);
2226
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2227
2228
2229
2230
2231
2232
2233
2234
2235

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

    EXPECT(p == prog);
}

TEST_CASE(resize_upsample_pc_test)
{
    migraphx::program p;
2236
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2237
2238
2239

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

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

2245
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2246
2247
2248

    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};
2249
    auto li              = mm->add_literal(migraphx::literal(si, ind));
Shucai Xiao's avatar
Shucai Xiao committed
2250

2251
2252
    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);
2253
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2254
2255
2256
2257
2258
2259
2260
2261
2262

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

    EXPECT(p == prog);
}

TEST_CASE(resize_upsample_pf_test)
{
    migraphx::program p;
2263
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2264
2265
2266

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

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

2272
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2273
2274
2275

    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};
2276
    auto li              = mm->add_literal(migraphx::literal(si, ind));
Shucai Xiao's avatar
Shucai Xiao committed
2277

2278
2279
    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);
2280
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2281
2282
2283
2284
2285
2286

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2287
2288
2289
TEST_CASE(round_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2290
2291
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
2292
    mm->add_instruction(migraphx::make_op("round"), input);
Khalique's avatar
Khalique committed
2293

Shucai Xiao's avatar
Shucai Xiao committed
2294
    auto prog = optimize_onnx("round_test.onnx");
Khalique's avatar
Khalique committed
2295
2296
2297
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2298
2299
2300
TEST_CASE(selu_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2301
    auto* mm                      = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2302
2303
    std::vector<std::size_t> lens = {2, 3};
    migraphx::shape s{migraphx::shape::double_type, lens};
Shucai Xiao's avatar
Shucai Xiao committed
2304
    auto x = mm->add_parameter("x", s);
Shucai Xiao's avatar
Shucai Xiao committed
2305
2306

    migraphx::shape ls{migraphx::shape::double_type, {1}};
2307
2308
2309
2310
2311
2312
    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
2313

2314
2315
    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
2316

2317
2318
    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
2319

2320
2321
    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
2322

2323
2324
2325
    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
2326
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2327
2328
2329
2330
2331
2332

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2333
TEST_CASE(shape_test)
2334
2335
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2336
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2337
    migraphx::shape s{migraphx::shape::float_type, {3, 4, 5, 6}};
Shucai Xiao's avatar
Shucai Xiao committed
2338
    auto l0 = mm->add_parameter("x", s);
Khalique's avatar
Khalique committed
2339
    migraphx::shape s_shape{migraphx::shape::int64_type, {4}};
Shucai Xiao's avatar
Shucai Xiao committed
2340
    mm->add_literal(s_shape, l0->get_shape().lens());
Shucai Xiao's avatar
Shucai Xiao committed
2341
    auto prog = optimize_onnx("shape_test.onnx");
2342
2343
2344
2345

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2346
TEST_CASE(shape_gather_test)
2347
2348
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2349
2350
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {7, 3, 10}});
2351
    migraphx::shape const_shape{migraphx::shape::int32_type, {1}};
Shucai Xiao's avatar
Shucai Xiao committed
2352
    auto l2 = mm->add_literal(migraphx::literal{const_shape, {1}});
Khalique's avatar
Khalique committed
2353
    auto l1 =
Shucai Xiao's avatar
Shucai Xiao committed
2354
        mm->add_literal(migraphx::shape{migraphx::shape::int64_type, {3}}, l0->get_shape().lens());
Khalique's avatar
Khalique committed
2355
    int axis = 0;
2356
    mm->add_instruction(migraphx::make_op("gather", {{"axis", axis}}), l1, l2);
Shucai Xiao's avatar
Shucai Xiao committed
2357
    auto prog = optimize_onnx("shape_gather_test.onnx");
2358
2359
2360
2361

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2362
TEST_CASE(sign_test)
Khalique's avatar
Khalique committed
2363
2364
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2365
2366
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
2367
    mm->add_instruction(migraphx::make_op("sign"), input);
Khalique's avatar
Khalique committed
2368

Shucai Xiao's avatar
Shucai Xiao committed
2369
    auto prog = optimize_onnx("sign_test.onnx");
Khalique's avatar
Khalique committed
2370
2371
2372
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2373
TEST_CASE(sin_test)
2374
2375
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2376
2377
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
2378
    mm->add_instruction(migraphx::make_op("sin"), input);
2379

Shucai Xiao's avatar
Shucai Xiao committed
2380
    auto prog = optimize_onnx("sin_test.onnx");
2381
2382
2383
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2384
TEST_CASE(sinh_test)
2385
2386
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2387
2388
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
2389
    mm->add_instruction(migraphx::make_op("sinh"), input);
Khalique's avatar
Khalique committed
2390

Shucai Xiao's avatar
Shucai Xiao committed
2391
    auto prog = optimize_onnx("sinh_test.onnx");
2392
2393
2394
2395

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
2396
2397
2398
TEST_CASE(slice_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2399
2400
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 2}});
2401
2402
    mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {1, 0}}, {"ends", {2, 2}}}), l0);
kahmed10's avatar
kahmed10 committed
2403
2404
2405
2406
2407
2408
2409
2410
    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
2411
2412
2413
2414
    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}});
2415
2416
    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
2417
    mm->add_return({ret});
kahmed10's avatar
kahmed10 committed
2418
2419
2420
2421
2422
2423

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2424
2425
2426
TEST_CASE(slice_5arg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2427
2428
2429
2430
2431
2432
    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}});
2433
2434
2435
    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
2436
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
2437
2438
2439
2440
2441
2442

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

    EXPECT(p == prog);
}

2443
2444
2445
TEST_CASE(slice_max_end_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2446
2447
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {10, 20}});
2448
2449
2450
2451
    mm->add_instruction(
        migraphx::make_op("slice",
                          {{"axes", {0, 1}}, {"starts", {1, 2}}, {"ends", {3000000000, -1}}}),
        l0);
2452
2453
2454
2455
2456
    auto prog = optimize_onnx("slice_max_end_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2457
TEST_CASE(softmax_test)
Shucai Xiao's avatar
Shucai Xiao committed
2458
2459
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2460
2461
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
2462
    mm->add_instruction(migraphx::make_op("softmax", {{"axis", 1}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2463
    auto prog = optimize_onnx("softmax_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2464
2465
2466
2467

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2468
2469
2470
TEST_CASE(split_minus_axis_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2471
2472
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2473
2474
2475
2476
2477
2478
    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
2479
    mm->add_return({r1, r2, r3});
Shucai Xiao's avatar
Shucai Xiao committed
2480
2481
2482
2483
2484
2485

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

    EXPECT(p == prog);
}

2486
2487
2488
TEST_CASE(split_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2489
2490
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2491
2492
2493
2494
2495
2496
    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
2497
    mm->add_return({r1, r2, r3});
2498
2499
2500
2501
2502
2503
2504
2505

    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
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
    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
2512
    mm->add_return({r1, r2});
2513
2514
2515
2516
2517

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

Khalique's avatar
Khalique committed
2518
TEST_CASE(sqrt_test)
Shucai Xiao's avatar
Shucai Xiao committed
2519
2520
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2521
2522
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2523
    mm->add_instruction(migraphx::make_op("sqrt"), input);
Shucai Xiao's avatar
Shucai Xiao committed
2524

Shucai Xiao's avatar
Shucai Xiao committed
2525
    auto prog = optimize_onnx("sqrt_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2526
2527
2528
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2529
TEST_CASE(squeeze_unsqueeze_test)
Khalique's avatar
Khalique committed
2530
2531
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2532
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2533
2534
2535
    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
2536
        mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 1, 1, 2, 1}});
2537
2538
    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
2539
    auto prog = optimize_onnx("squeeze_unsqueeze_test.onnx");
Khalique's avatar
Khalique committed
2540
2541
2542
2543

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2544
TEST_CASE(sub_bcast_test)
Shucai Xiao's avatar
Shucai Xiao committed
2545
2546
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2547
2548
2549
    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}});
2550
2551
2552
    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
2553

Shucai Xiao's avatar
Shucai Xiao committed
2554
    auto prog = optimize_onnx("sub_bcast_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2555
2556
2557
2558

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2559
TEST_CASE(sub_scalar_test)
Shucai Xiao's avatar
Shucai Xiao committed
2560
2561
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2562
2563
2564
    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}});
2565
2566
2567
    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
2568
    auto prog = optimize_onnx("sub_scalar_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2569
2570
2571
2572

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2573
2574
2575
TEST_CASE(sum_int_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2576
2577
2578
2579
    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}});
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
    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
2590
2591
2592
2593
2594

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

Khalique's avatar
Khalique committed
2595
TEST_CASE(sum_test)
2596
2597
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2598
2599
2600
2601
    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}});
2602
2603
    auto l0     = mm->add_instruction(migraphx::make_op("add"), input0, input1);
    mm->add_instruction(migraphx::make_op("add"), l0, input2);
2604

Shucai Xiao's avatar
Shucai Xiao committed
2605
    auto prog = optimize_onnx("sum_test.onnx");
2606
2607
2608
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2609
2610
2611
TEST_CASE(sum_type_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2612
2613
2614
2615
2616
2617
2618
2619
2620
    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}});
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
    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
2652
    mm->add_return({s6});
Shucai Xiao's avatar
Shucai Xiao committed
2653
2654
2655
2656
2657
2658

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2659
TEST_CASE(tan_test)
2660
2661
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2662
2663
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
2664
    mm->add_instruction(migraphx::make_op("tan"), input);
2665

Shucai Xiao's avatar
Shucai Xiao committed
2666
    auto prog = optimize_onnx("tan_test.onnx");
2667
2668
2669
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2670
TEST_CASE(tanh_test)
2671
2672
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2673
2674
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}});
2675
    mm->add_instruction(migraphx::make_op("tanh"), input);
2676

Shucai Xiao's avatar
Shucai Xiao committed
2677
    auto prog = optimize_onnx("tanh_test.onnx");
2678
2679
2680
2681

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
2682
2683
2684
TEST_CASE(tile_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2685
2686
2687
    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}});
2688
    mm->add_instruction(migraphx::make_op("concat", {{"axis", 1}}), input, input);
kahmed10's avatar
kahmed10 committed
2689
2690
2691
2692
2693
2694
2695
2696
2697

    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
2698
2699
2700
    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}});
2701
2702
2703
    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
2704
2705
2706
2707
2708
2709

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2710
TEST_CASE(transpose_test)
2711
2712
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2713
2714
    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
2715
    std::vector<int64_t> perm{0, 3, 1, 2};
2716
    mm->add_instruction(migraphx::make_op("transpose", {{"dims", perm}}), input);
Khalique's avatar
Khalique committed
2717

Shucai Xiao's avatar
Shucai Xiao committed
2718
    auto prog = optimize_onnx("transpose_test.onnx");
2719
2720
2721
2722

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2723
TEST_CASE(transpose_gather_test)
2724
2725
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2726
2727
    auto* mm             = p.get_main_module();
    auto make_contiguous = [&mm](migraphx::instruction_ref ins) {
Khalique's avatar
Khalique committed
2728
2729
2730
2731
2732
        if(ins->get_shape().standard())
        {
            return ins;
        }

2733
        return mm->add_instruction(migraphx::make_op("contiguous"), ins);
Khalique's avatar
Khalique committed
2734
2735
    };

Shucai Xiao's avatar
Shucai Xiao committed
2736
2737
    auto data =
        mm->add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 5, 4, 6}});
Khalique's avatar
Khalique committed
2738
    auto ind =
Shucai Xiao's avatar
Shucai Xiao committed
2739
        mm->add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 4, 3, 5}});
2740
2741
2742
2743
2744
2745
2746
2747
    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
2748

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

2751
    EXPECT(p.sort() == prog.sort());
2752
2753
}

2754
2755
2756
TEST_CASE(undefined_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2757
2758
    auto* mm = p.get_main_module();
    mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
2759
2760
    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
2761
    mm->add_return({l2});
2762
2763
2764
2765
2766
2767

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2768
TEST_CASE(unknown_test)
2769
2770
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2771
2772
2773
2774
2775
    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
2776
    auto prog = optimize_onnx("unknown_test.onnx");
2777
2778
2779
2780

    EXPECT(p == prog);
}

2781
2782
2783
2784
2785
TEST_CASE(unknown_aten_test)
{
    EXPECT(test::throws([&] { migraphx::parse_onnx("unknown_aten_test.onnx"); }));
}

2786
2787
2788
2789
2790
TEST_CASE(unknown_test_throw)
{
    EXPECT(test::throws([&] { migraphx::parse_onnx("unknown_test.onnx"); }));
}

Shucai Xiao's avatar
Shucai Xiao committed
2791
2792
2793
TEST_CASE(upsample_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2794
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2795
    migraphx::shape ss{migraphx::shape::float_type, {4}};
Shucai Xiao's avatar
Shucai Xiao committed
2796
    mm->add_literal(migraphx::literal(ss, {1.0f, 1.0f, 2.0f, 3.0f}));
Shucai Xiao's avatar
Shucai Xiao committed
2797
2798

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
Shucai Xiao's avatar
Shucai Xiao committed
2799
    auto ix = mm->add_parameter("X", sx);
Shucai Xiao's avatar
Shucai Xiao committed
2800
2801
2802
2803

    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
2804
    auto li  = mm->add_literal(migraphx::literal(si, ind));
2805
2806
    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
2807
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2808
2809
2810
2811
2812
2813

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

    EXPECT(p == prog);
}

2814
2815
2816
2817
2818
2819
2820
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); }));
}

2821
2822
2823
TEST_CASE(variable_batch_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2824
2825
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
2826
    mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2827
    auto prog = optimize_onnx("variable_batch_test.onnx");
2828
2829
2830
2831

    EXPECT(p == prog);
}

2832
2833
2834
TEST_CASE(variable_batch_user_input_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2835
2836
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 16, 16}});
2837
    auto r   = mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2838
    mm->add_return({r});
2839
2840
2841
2842
2843
2844
2845
2846
2847

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

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

    EXPECT(p == prog);
}

2848
2849
2850
TEST_CASE(variable_batch_leq_zero_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2851
2852
2853
    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}});
2854
    mm->add_instruction(migraphx::make_op("add"), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
2855
    auto prog = optimize_onnx("variable_batch_leq_zero_test.onnx");
2856
2857
2858
2859

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2860
2861
2862
TEST_CASE(where_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2863
2864
2865
2866
2867
    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}});

2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
    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
2882
2883
2884
2885
2886
2887
2888
2889
2890

    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));

2891
2892
2893
    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
2894
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2895
2896
2897
2898
2899
2900

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

    EXPECT(p == prog);
}

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