onnx_test.cpp 116 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);
}

899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
TEST_CASE(dequantizelinear_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::int8_type, {5}});
    auto l1  = mm->add_parameter("1", {migraphx::shape::float_type, {1}});
    auto l2  = mm->add_parameter("2", {migraphx::shape::int8_type, {1}});
    auto l1_mbcast =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {5}}}), l1);
    l2 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int32_type)}}),
        l2);
    auto l2_mbcast =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {5}}}), l2);
    l0 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int32_type)}}),
        l0);

    auto sub     = mm->add_instruction(migraphx::make_op("sub"), l0, l2_mbcast);
    auto dequant = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
        sub);

    mm->add_instruction(migraphx::make_op("mul"), dequant, l1_mbcast);

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

migraphx::program make_dequantizelinear_axis_prog()
{
    migraphx::program p;
    std::vector<size_t> input_lens{1, 1, 5, 1};
    int axis      = 2;
    auto* mm      = p.get_main_module();
    auto l0       = mm->add_parameter("0", {migraphx::shape::int8_type, input_lens});
    auto l1       = mm->add_parameter("1", {migraphx::shape::float_type, {5}});
    auto l2       = mm->add_parameter("2", {migraphx::shape::int8_type, {5}});
    auto l1_bcast = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", input_lens}}), l1);
    auto l2_bcast = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", input_lens}}), l2);
    l2_bcast = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int32_type)}}),
        l2_bcast);
    l0 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int32_type)}}),
        l0);
    auto sub     = mm->add_instruction(migraphx::make_op("sub"), l0, l2_bcast);
    auto dequant = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
        sub);

    mm->add_instruction(migraphx::make_op("mul"), dequant, l1_bcast);
    return p;
}

TEST_CASE(dequantizelinear_axis_test)
{
    migraphx::program p = make_dequantizelinear_axis_prog();

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

TEST_CASE(dequantizelinear_neg_axis_test)
{
    migraphx::program p = make_dequantizelinear_axis_prog();

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

Khalique's avatar
Khalique committed
978
TEST_CASE(dropout_test)
Shucai Xiao's avatar
Shucai Xiao committed
979
980
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
981
982
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}});
983
    auto out   = mm->add_instruction(migraphx::make_op("identity"), input);
984
985
    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
986
987
    mm->add_literal(migraphx::literal(s, vec));
    mm->add_return({out});
Shucai Xiao's avatar
Shucai Xiao committed
988

989
    auto prog = migraphx::parse_onnx("dropout_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
990
991
992
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
993
994
995
TEST_CASE(elu_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
996
997
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
998
    mm->add_instruction(migraphx::make_op("elu", {{"alpha", 0.01}}), input);
Khalique's avatar
Khalique committed
999

Shucai Xiao's avatar
Shucai Xiao committed
1000
    auto prog = optimize_onnx("elu_test.onnx");
Khalique's avatar
Khalique committed
1001
1002
1003
1004

    EXPECT(p == prog);
}

1005
1006
1007
TEST_CASE(embedding_bag_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1008
1009
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("weight", migraphx::shape{migraphx::shape::float_type, {4, 2}});
1010
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {3}}, {1, 0, 2}};
Shucai Xiao's avatar
Shucai Xiao committed
1011
1012
    auto l1 = mm->add_literal(l);
    mm->add_literal(0);
1013
1014
1015
1016
1017
1018
    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
1019
    mm->add_return({r1, r2, r3});
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030

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

1031
1032
1033
TEST_CASE(equal_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1034
    auto* mm = p.get_main_module();
1035
1036
1037
    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
1038
1039
    auto input1 = mm->add_literal(migraphx::literal(s, data));
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
1040
1041
1042
1043
1044
    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
1045
    mm->add_return({ret});
1046
1047
1048
1049
1050
1051
1052
1053
1054

    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
1055
    auto* mm = p.get_main_module();
1056
1057
1058
    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
1059
1060
    auto input1 = mm->add_parameter("x1", sf);
    auto input2 = mm->add_parameter("x2", sb);
1061
1062
1063
1064
1065
    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
1066
    mm->add_return({ret});
1067
1068
1069
1070
1071
1072

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1073
TEST_CASE(erf_test)
1074
1075
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1076
1077
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
1078
    mm->add_instruction(migraphx::make_op("erf"), input);
Khalique's avatar
Khalique committed
1079

Shucai Xiao's avatar
Shucai Xiao committed
1080
    auto prog = optimize_onnx("erf_test.onnx");
Khalique's avatar
Khalique committed
1081
1082
1083
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1084
TEST_CASE(exp_test)
1085
1086
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1087
1088
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
1089
    mm->add_instruction(migraphx::make_op("exp"), input);
Khalique's avatar
Khalique committed
1090

Shucai Xiao's avatar
Shucai Xiao committed
1091
    auto prog = optimize_onnx("exp_test.onnx");
Khalique's avatar
Khalique committed
1092
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
1093
1094
}

Khalique's avatar
Khalique committed
1095
TEST_CASE(expand_test)
1096
1097
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1098
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
1099
    migraphx::shape s(migraphx::shape::float_type, {3, 1, 1});
Shucai Xiao's avatar
Shucai Xiao committed
1100
    auto param = mm->add_parameter("x", s);
Khalique's avatar
Khalique committed
1101
    migraphx::shape ss(migraphx::shape::int32_type, {4});
Shucai Xiao's avatar
Shucai Xiao committed
1102
    mm->add_literal(migraphx::literal(ss, {2, 3, 4, 5}));
1103
1104
    mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 4, 5}}}),
                        param);
Khalique's avatar
Khalique committed
1105

Shucai Xiao's avatar
Shucai Xiao committed
1106
    auto prog = optimize_onnx("expand_test.onnx");
Khalique's avatar
Khalique committed
1107
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
1108
1109
}

1110
1111
1112
migraphx::program create_external_data_prog()
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1113
    auto* mm = p.get_main_module();
1114
1115
1116
1117
    migraphx::shape s(migraphx::shape::float_type, {1, 1, 224, 224});
    migraphx::shape s2(migraphx::shape::float_type, {10, 1, 11, 11});
    std::vector<float> weight_data(1210, 1);
    std::vector<float> bias_data(10, 1);
Shucai Xiao's avatar
Shucai Xiao committed
1118
1119
1120
1121
1122
    auto bias = mm->add_literal(migraphx::literal({migraphx::shape::float_type, {10}}, bias_data));
    auto weights    = mm->add_literal(migraphx::literal(s2, weight_data));
    auto param      = mm->add_parameter("input", s);
    auto conv       = mm->add_instruction(migraphx::make_op("convolution"), param, weights);
    auto bias_bcast = mm->add_instruction(
1123
        migraphx::make_op("broadcast", {{"axis", 1}, {"dims", {1, 10, 214, 214}}}), bias);
Shucai Xiao's avatar
Shucai Xiao committed
1124
    mm->add_instruction(migraphx::make_op("add"), conv, bias_bcast);
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
    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
1144
TEST_CASE(flatten_test)
1145
1146
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1147
1148
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
1149
1150
    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
1151
    auto prog = optimize_onnx("flatten_test.onnx");
1152
1153
1154
1155

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1156
1157
1158
TEST_CASE(floor_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1159
1160
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
1161
    mm->add_instruction(migraphx::make_op("floor"), input);
Shucai Xiao's avatar
Shucai Xiao committed
1162

Shucai Xiao's avatar
Shucai Xiao committed
1163
    auto prog = optimize_onnx("floor_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1164
1165
1166
1167

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1168
TEST_CASE(gather_test)
1169
1170
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1171
1172
1173
    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
1174
    int axis = 1;
1175
    mm->add_instruction(migraphx::make_op("gather", {{"axis", axis}}), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1176
    auto prog = optimize_onnx("gather_test.onnx");
1177
1178
1179
1180

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1181
1182
1183
TEST_CASE(gather_elements_axis0_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1184
1185
1186
    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
1187
1188
1189
1190
    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
1191
        mm->add_literal(migraphx::literal{ind_s, ind_indices.begin(), ind_indices.end()});
Shucai Xiao's avatar
Shucai Xiao committed
1192
    auto l_ind_axis_indices =
Shucai Xiao's avatar
Shucai Xiao committed
1193
1194
        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
1195

1196
1197
1198
1199
1200
1201
1202
    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
1203
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1204
1205
1206
1207
1208
1209
1210
1211
1212

    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
1213
1214
1215
    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
1216
1217
1218
1219
    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
1220
        mm->add_literal(migraphx::literal{ind_s, ind_indices.begin(), ind_indices.end()});
Shucai Xiao's avatar
Shucai Xiao committed
1221
    auto l_ind_axis_indices =
Shucai Xiao's avatar
Shucai Xiao committed
1222
1223
        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
1224

1225
1226
1227
1228
1229
1230
1231
    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
1232
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1233
1234
1235
1236
1237
1238

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1239
TEST_CASE(gemm_test)
1240
1241
{
    migraphx::program p;
1242
1243
1244
1245
1246
1247
1248
1249
    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
1250
1251
    auto alpha = 2.f;
    auto beta  = 2.0f;
1252
    mm->add_instruction(migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), t0, t1, bl2);
Shucai Xiao's avatar
Shucai Xiao committed
1253
    auto prog = optimize_onnx("gemm_test.onnx");
1254
1255
1256
1257

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1258
TEST_CASE(gemm_ex_test)
1259
1260
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1261
1262
1263
1264
    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}});
1265
    auto t0    = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 1, 3, 2}}}), l0);
Khalique's avatar
Khalique committed
1266
1267
    auto alpha = 0.5f;
    auto beta  = 0.8f;
1268
    mm->add_instruction(migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), t0, l1, l2);
Shucai Xiao's avatar
Shucai Xiao committed
1269
    auto prog = optimize_onnx("gemm_ex_test.onnx");
1270
1271
1272
1273

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1274
TEST_CASE(gemm_ex_brcst_test)
1275
1276
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1277
1278
1279
1280
    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}});
1281
    auto t0  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 1, 3, 2}}}), l0);
Khalique's avatar
Khalique committed
1282
    std::vector<std::size_t> out_lens{1, 1, 6, 7};
1283
1284
    auto t2 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", out_lens}}), l2);
Khalique's avatar
Khalique committed
1285
1286
    auto alpha = 0.5f;
    auto beta  = 0.8f;
1287
    mm->add_instruction(migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), t0, l1, t2);
Shucai Xiao's avatar
Shucai Xiao committed
1288
    auto prog = optimize_onnx("gemm_ex_brcst_test.onnx");
1289
1290
1291
1292

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1293
TEST_CASE(globalavgpool_test)
1294
1295
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1296
1297
1298
    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
1299
1300
1301
    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
1302
    mm->add_instruction(op, input);
Khalique's avatar
Khalique committed
1303

Shucai Xiao's avatar
Shucai Xiao committed
1304
    auto prog = optimize_onnx("globalavgpool_test.onnx");
1305
1306
1307
1308

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1309
TEST_CASE(globalmaxpool_test)
Khalique's avatar
Khalique committed
1310
1311
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1312
1313
1314
    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
1315
1316
1317
    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
1318
    mm->add_instruction(op, input);
Khalique's avatar
Khalique committed
1319

Shucai Xiao's avatar
Shucai Xiao committed
1320
    auto prog = optimize_onnx("globalmaxpool_test.onnx");
Khalique's avatar
Khalique committed
1321
1322
1323
1324

    EXPECT(p == prog);
}

1325
1326
1327
TEST_CASE(greater_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1328
    auto* mm = p.get_main_module();
1329
1330
1331
    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
1332
1333
    auto input1 = mm->add_literal(migraphx::literal(s, data));
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
1334
1335
1336
1337
1338
    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
1339
    mm->add_return({ret});
1340
1341
1342
1343
1344
1345
1346
1347

    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
1348
    auto* mm = p.get_main_module();
1349
1350
1351
    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
1352
1353
    auto input1 = mm->add_parameter("x1", sf);
    auto input2 = mm->add_parameter("x2", sb);
1354
1355
1356
1357
1358
    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
1359
    mm->add_return({ret});
1360
1361
1362
1363
1364

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

Khalique's avatar
Khalique committed
1365
TEST_CASE(group_conv_test)
1366
1367
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1368
1369
1370
    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
1371
1372
    migraphx::op::convolution op;
    op.group = 4;
Shucai Xiao's avatar
Shucai Xiao committed
1373
    mm->add_instruction(op, l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1374
    auto prog = optimize_onnx("group_conv_test.onnx");
1375
1376
1377
1378

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1379
TEST_CASE(imagescaler_test)
1380
1381
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1382
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
1383
    migraphx::shape s{migraphx::shape::float_type, {1, 3, 16, 16}};
Shucai Xiao's avatar
Shucai Xiao committed
1384
1385
1386
    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
1387
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
1388
1389
1390
1391
1392
1393
    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
1394

Shucai Xiao's avatar
Shucai Xiao committed
1395
    auto prog = optimize_onnx("imagescaler_test.onnx");
1396
1397
1398
1399

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1400
1401
1402
TEST_CASE(imagescaler_half_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1403
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1404
    migraphx::shape s{migraphx::shape::half_type, {1, 3, 16, 16}};
Shucai Xiao's avatar
Shucai Xiao committed
1405
    auto l0 = mm->add_parameter("0", s);
Shucai Xiao's avatar
Shucai Xiao committed
1406
    auto scale_val =
Shucai Xiao's avatar
Shucai Xiao committed
1407
1408
        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
1409
        migraphx::literal{migraphx::shape{migraphx::shape::half_type, {3}}, {0.01, 0.02, 0.03}});
1410
1411
1412
1413
1414
1415
    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
1416
1417
1418
1419
1420
1421

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1422
TEST_CASE(implicit_add_bcast_test)
1423
1424
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1425
1426
1427
    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}});
1428
1429
1430
    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
1431

Shucai Xiao's avatar
Shucai Xiao committed
1432
    auto prog = optimize_onnx("implicit_add_bcast_test.onnx");
1433
1434
1435
1436

    EXPECT(p == prog);
}

1437
1438
1439
TEST_CASE(implicit_add_bcast_user_input_shape_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1440
1441
1442
    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}});
1443
1444
1445
    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
1446
    mm->add_return({r});
1447
1448
1449
1450
1451
1452
1453
1454
1455

    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
1456
TEST_CASE(implicit_pow_bcast_test)
1457
1458
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1459
1460
1461
    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}});
1462
1463
1464
    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
1465

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1471
TEST_CASE(implicit_sub_bcast_test)
1472
1473
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1474
1475
1476
    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}});
1477
1478
1479
    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
1480

Shucai Xiao's avatar
Shucai Xiao committed
1481
    auto prog = optimize_onnx("implicit_sub_bcast_test.onnx");
1482
1483
1484
1485

    EXPECT(p == prog);
}

1486
1487
1488
TEST_CASE(initializer_not_an_input)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1489
    auto* mm             = p.get_main_module();
1490
    std::vector<float> w = {1, 2, 3, 4, 5, 6, 7, 8};
Shucai Xiao's avatar
Shucai Xiao committed
1491
1492
    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}});
1493
    mm->add_instruction(migraphx::make_op("dot"), l0, l1);
1494

Shucai Xiao's avatar
Shucai Xiao committed
1495
    auto prog = optimize_onnx("initializer_not_an_input.onnx");
kahmed10's avatar
kahmed10 committed
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506

    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
1507
1508
1509
1510
1511
    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);

1512
1513
1514
1515
1516
1517
    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
1518
    auto epsilon_literal = mm->add_literal(1e-5f);
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
    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
1532
1533

    auto prog = optimize_onnx("instance_norm_test.onnx");
1534
1535
1536
1537

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1538
TEST_CASE(leaky_relu_test)
1539
1540
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1541
    auto* mm    = p.get_main_module();
Khalique's avatar
Khalique committed
1542
    float alpha = 0.01f;
Shucai Xiao's avatar
Shucai Xiao committed
1543
    auto l0     = mm->add_parameter("0", {migraphx::shape::float_type, {3}});
1544
    mm->add_instruction(migraphx::make_op("leaky_relu", {{"alpha", alpha}}), l0);
Khalique's avatar
Khalique committed
1545

Shucai Xiao's avatar
Shucai Xiao committed
1546
    auto prog = optimize_onnx("leaky_relu_test.onnx");
1547
1548
1549
1550

    EXPECT(p == prog);
}

1551
1552
1553
TEST_CASE(less_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1554
    auto* mm = p.get_main_module();
1555
1556
1557
    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
1558
1559
    auto input1 = mm->add_literal(migraphx::literal(s, data));
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
1560
1561
1562
1563
1564
    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
1565
    mm->add_return({ret});
1566
1567
1568
1569
1570
1571
1572
1573

    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
1574
    auto* mm = p.get_main_module();
1575
1576
1577
    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
1578
1579
    auto input1 = mm->add_parameter("x1", sf);
    auto input2 = mm->add_parameter("x2", sb);
1580
1581
1582
1583
1584
    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
1585
    mm->add_return({ret});
1586
1587
1588
1589
1590

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

Khalique's avatar
Khalique committed
1591
TEST_CASE(log_test)
1592
1593
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1594
1595
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
1596
    mm->add_instruction(migraphx::make_op("log"), input);
1597

Shucai Xiao's avatar
Shucai Xiao committed
1598
    auto prog = optimize_onnx("log_test.onnx");
1599
1600
1601
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
TEST_CASE(logical_and_bcast_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::bool_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::bool_type, {4, 5}});
    auto l2  = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", l0->get_shape().lens()}}), l1);
    auto ret = mm->add_instruction(migraphx::make_op("logical_and"), l0, l2);
    mm->add_return({ret});

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

    EXPECT(p == prog);
}

TEST_CASE(logical_or_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::bool_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::bool_type, {2, 3, 4, 5}});
    auto ret = mm->add_instruction(migraphx::make_op("logical_or"), l0, l1);
    mm->add_return({ret});

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

    EXPECT(p == prog);
}

TEST_CASE(logical_xor_bcast_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::bool_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::bool_type, {4, 1}});
    auto l2  = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"output_lens", l0->get_shape().lens()}}), l1);
    auto ret = mm->add_instruction(migraphx::make_op("logical_xor"), l0, l2);
    mm->add_return({ret});

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1648
TEST_CASE(logsoftmax_test)
1649
1650
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1651
1652
    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
1653
    int axis = 1;
1654
    mm->add_instruction(migraphx::make_op("logsoftmax", {{"axis", axis}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
1655
    auto prog = optimize_onnx("logsoftmax_test.onnx");
1656
1657
1658
1659

    EXPECT(p == prog);
}

1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
TEST_CASE(logsoftmax_nonstd_input_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {6, 9}});
    auto l1  = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {1, 0}}, {"ends", {4, 4}}}), l0);
    auto l2 = mm->add_instruction(migraphx::make_op("logsoftmax", {{"axis", 1}}), l1);
    mm->add_return({l2});

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1675
TEST_CASE(lrn_test)
1676
1677
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1678
1679
    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
1680
1681
1682
1683
1684
    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
1685
    mm->add_instruction(op, l0);
Shucai Xiao's avatar
Shucai Xiao committed
1686
    auto prog = optimize_onnx("lrn_test.onnx");
1687
1688
1689
1690

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1691
TEST_CASE(matmul_bmbm_test)
1692
1693
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1694
1695
1696
    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}});
1697
1698
1699
1700
1701
    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
1702

Shucai Xiao's avatar
Shucai Xiao committed
1703
    auto prog = optimize_onnx("matmul_bmbm_test.onnx");
1704
1705
1706
1707

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1708
TEST_CASE(matmul_bmv_test)
1709
{
Khalique's avatar
Khalique committed
1710
    migraphx::program p;
1711
1712
1713
1714
1715
1716
1717
1718
1719
    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);
1720

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

Khalique's avatar
Khalique committed
1723
    EXPECT(p == prog);
1724
1725
}

Khalique's avatar
Khalique committed
1726
TEST_CASE(matmul_mv_test)
1727
1728
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1729
1730
1731
    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}});
1732
1733
1734
1735
    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
1736

Shucai Xiao's avatar
Shucai Xiao committed
1737
    auto prog = optimize_onnx("matmul_mv_test.onnx");
1738
1739
1740
1741

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1742
TEST_CASE(matmul_vbm_test)
1743
1744
{
    migraphx::program p;
1745
1746
1747
1748
1749
1750
1751
1752
1753
    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
1754

Shucai Xiao's avatar
Shucai Xiao committed
1755
    auto prog = optimize_onnx("matmul_vbm_test.onnx");
1756
1757
1758
1759

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1760
TEST_CASE(matmul_vm_test)
1761
1762
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1763
1764
1765
    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}});
1766
1767
1768
1769
    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
1770

Shucai Xiao's avatar
Shucai Xiao committed
1771
    auto prog = optimize_onnx("matmul_vm_test.onnx");
1772
1773
1774
1775

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1776
TEST_CASE(matmul_vv_test)
1777
1778
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1779
1780
1781
    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}});
1782
1783
1784
1785
1786
1787
    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);
1788

Shucai Xiao's avatar
Shucai Xiao committed
1789
    auto prog = optimize_onnx("matmul_vv_test.onnx");
1790
1791
1792
1793

    EXPECT(p == prog);
}

1794
1795
1796
TEST_CASE(matmulinteger_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1797
1798
1799
    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}});
1800
    mm->add_instruction(migraphx::make_op("quant_dot", {{"alpha", 1}, {"beta", 0}}), l0, l1);
1801
1802
1803
1804
1805
1806

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1807
TEST_CASE(max_test)
1808
1809
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1810
1811
1812
1813
    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}});
1814
1815
    auto l0     = mm->add_instruction(migraphx::make_op("max"), input0, input1);
    mm->add_instruction(migraphx::make_op("max"), l0, input2);
1816

Shucai Xiao's avatar
Shucai Xiao committed
1817
    optimize_onnx("max_test.onnx");
Khalique's avatar
Khalique committed
1818
}
1819

1820
1821
1822
TEST_CASE(maxpool_notset_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1823
1824
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
1825
1826
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
    float val                 = std::numeric_limits<float>::lowest();
1827
1828
1829
1830
1831
1832
1833
    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);
1834
1835
1836
1837
1838
1839
1840
1841
1842

    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
1843
1844
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
1845
1846
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
    float val                 = std::numeric_limits<float>::lowest();
1847
1848
1849
1850
1851
1852
1853
    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);
1854
1855
1856
1857
1858
1859

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1860
1861
1862
TEST_CASE(min_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1863
1864
1865
1866
    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}});
1867
1868
    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
1869

Shucai Xiao's avatar
Shucai Xiao committed
1870
    optimize_onnx("min_test.onnx");
1871
1872
}

Khalique's avatar
Khalique committed
1873
TEST_CASE(no_pad_test)
1874
1875
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1876
1877
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
1878
    mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
1879
    auto prog = optimize_onnx("no_pad_test.onnx");
1880

Khalique's avatar
Khalique committed
1881
1882
1883
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1884
1885
1886
TEST_CASE(neg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1887
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1888
    migraphx::shape s{migraphx::shape::int64_type, {2, 3}};
Shucai Xiao's avatar
Shucai Xiao committed
1889
    auto input = mm->add_parameter("0", s);
1890
    auto ret   = mm->add_instruction(migraphx::make_op("neg"), input);
Shucai Xiao's avatar
Shucai Xiao committed
1891
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1892
1893
1894
1895
1896
1897

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1898
1899
1900
TEST_CASE(nonzero_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1901
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1902
1903
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
    std::vector<float> data = {1, 0, 1, 1};
Shucai Xiao's avatar
Shucai Xiao committed
1904
    mm->add_literal(migraphx::literal(s, data));
Shucai Xiao's avatar
Shucai Xiao committed
1905
1906
1907

    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
1908
1909
    auto r                       = mm->add_literal(migraphx::literal(si, indices));
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1910
1911
1912
1913
1914
1915
1916
1917

    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
1918
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1919
    migraphx::shape s{migraphx::shape::int16_type, {2, 3}};
Shucai Xiao's avatar
Shucai Xiao committed
1920
    std::vector<int> data = {1, 1, 0, 1, 0, 1};
Shucai Xiao's avatar
Shucai Xiao committed
1921
    mm->add_literal(migraphx::literal(s, data.begin(), data.end()));
Shucai Xiao's avatar
Shucai Xiao committed
1922
1923
1924

    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
1925
1926
    auto r                       = mm->add_literal(migraphx::literal(si, indices));
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1927
1928
1929
1930
1931

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

kahmed10's avatar
kahmed10 committed
1932
1933
1934
TEST_CASE(onehot_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1935
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1936
1937
    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
1938
1939
1940
    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
1941
1942
    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
1943
    auto l_dep      = mm->add_literal(migraphx::literal(s_dep, data_dep));
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
    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
1958
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1959
1960

    auto prog = migraphx::parse_onnx("onehot_test.onnx");
kahmed10's avatar
kahmed10 committed
1961
1962
1963
1964

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1965
1966
1967
TEST_CASE(pad_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1968
1969
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
1970
    mm->add_instruction(migraphx::make_op("pad", {{"pads", {1, 1, 1, 1}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
1971
    auto prog = optimize_onnx("pad_test.onnx");
1972
1973
1974
1975

    EXPECT(p == prog);
}

1976
1977
1978
TEST_CASE(pad_3arg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1979
1980
1981
1982
    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}});
1983
1984
    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
1985
    mm->add_return({r});
1986
1987
1988
1989
1990
1991

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
1992
1993
1994
TEST_CASE(pad_reflect_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1995
1996
1997
    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}});
1998
1999
2000
2001
2002
2003
2004
    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
2005
    mm->add_return({r});
kahmed10's avatar
kahmed10 committed
2006
2007
2008
2009
2010
2011
2012
2013
2014

    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
2015
2016
2017
    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}});
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
    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
2028
    mm->add_return({r});
kahmed10's avatar
kahmed10 committed
2029
2030
2031
2032
2033
2034

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2035
TEST_CASE(pow_test)
2036
2037
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2038
2039
2040
    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}});
2041
    mm->add_instruction(migraphx::make_op("pow"), l0, l1);
2042

Shucai Xiao's avatar
Shucai Xiao committed
2043
    auto prog = optimize_onnx("pow_test.onnx");
2044
2045
2046
2047

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
TEST_CASE(pow_fp32_i64_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::int64_type, {2, 3, 4, 5}});
    auto l1f = mm->add_instruction(
        migraphx::make_op("convert", {{"target_type", migraphx::shape::float_type}}), l1);
    auto ret = mm->add_instruction(migraphx::make_op("pow"), l0, l1f);
    mm->add_return({ret});

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

    EXPECT(p == prog);
}

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

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2082
2083
2084
TEST_CASE(prelu_brcst_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2085
2086
2087
    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}});
2088
2089
2090
    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
2091
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
2092
2093
2094
2095
2096
2097

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

    EXPECT(p == prog);
}

2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
TEST_CASE(quantizelinear_test)
{
    migraphx::program p;
    auto* mm     = p.get_main_module();
    auto l0      = mm->add_parameter("0", {migraphx::shape::float_type, {5}});
    auto l1      = mm->add_parameter("1", {migraphx::shape::float_type, {1}});
    auto l2      = mm->add_parameter("2", {migraphx::shape::int8_type, {1}});
    auto min_val = mm->add_literal(-128);
    auto max_val = mm->add_literal(127);

    auto l1_mbcast =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {5}}}), l1);

    auto div   = mm->add_instruction(migraphx::make_op("div"), l0, l1_mbcast);
    auto round = mm->add_instruction(migraphx::make_op("round"), div);
    l2         = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int32_type)}}),
        l2);
    auto l2_mbcast =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {5}}}), l2);

    round = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int32_type)}}),
        round);
    auto add  = mm->add_instruction(migraphx::make_op("add"), round, l2_mbcast);
    auto clip = mm->add_instruction(migraphx::make_op("clip"), add, min_val, max_val);
    mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int8_type)}}),
        clip);

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

migraphx::program make_quantizelinear_axis_prog()
{
    migraphx::program p;
    std::vector<size_t> input_lens{1, 1, 5, 1};
    int axis = 2;
    auto* mm = p.get_main_module();

    auto l0      = mm->add_parameter("0", {migraphx::shape::float_type, input_lens});
    auto l1      = mm->add_parameter("1", {migraphx::shape::float_type, {5}});
    auto l2      = mm->add_parameter("2", {migraphx::shape::int8_type, {5}});
    auto min_val = mm->add_literal(-128);
    auto max_val = mm->add_literal(127);

    auto l1_bcast = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", input_lens}}), l1);

    auto div      = mm->add_instruction(migraphx::make_op("div"), l0, l1_bcast);
    auto round    = mm->add_instruction(migraphx::make_op("round"), div);
    auto l2_bcast = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", axis}, {"dims", input_lens}}), l2);
    l2_bcast = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int32_type)}}),
        l2_bcast);
    round = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int32_type)}}),
        round);
    auto add  = mm->add_instruction(migraphx::make_op("add"), round, l2_bcast);
    auto clip = mm->add_instruction(migraphx::make_op("clip"), add, min_val, max_val);
    mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int8_type)}}),
        clip);
    return p;
}

TEST_CASE(quantizelinear_axis_test)
{
    migraphx::program p = make_quantizelinear_axis_prog();

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

TEST_CASE(quantizelinear_neg_axis_test)
{
    migraphx::program p = make_quantizelinear_axis_prog();

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

kahmed10's avatar
kahmed10 committed
2188
2189
2190
TEST_CASE(range_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2191
2192
2193
2194
2195
    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
2196
2197
2198
2199
2200
2201
2202
2203
2204

    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
2205
2206
2207
2208
2209
    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
2210
2211
2212
2213
2214
2215

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
2216
2217
2218
TEST_CASE(recip_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2219
2220
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3}});
2221
    mm->add_instruction(migraphx::make_op("recip"), input);
kahmed10's avatar
kahmed10 committed
2222
2223
2224
2225
2226
2227

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2228
2229
2230
TEST_CASE(reducel1_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2231
2232
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2233
2234
2235
    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
2236
2237
2238
2239
2240
2241
2242
2243
    auto prog = optimize_onnx("reducel1_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(reducel2_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2244
2245
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2246
2247
2248
2249
    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
2250
2251
2252
2253
2254
2255
2256
2257
    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
2258
2259
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2260
2261
    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
2262
2263
2264
2265
2266
2267
2268
2269
    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
2270
2271
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2272
2273
2274
    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
2275
2276
2277
2278
2279
    auto prog = optimize_onnx("reduce_log_sum_exp_test.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2280
2281
2282
TEST_CASE(reducemax_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2283
2284
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2285
    mm->add_instruction(migraphx::make_op("reduce_max", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2286
    auto prog = optimize_onnx("reducemax_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2287
2288
2289
2290

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2291
TEST_CASE(reducemean_test)
2292
2293
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2294
2295
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2296
2297
    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
2298
    auto prog = optimize_onnx("reducemean_test.onnx");
2299
2300
2301
2302

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2303
TEST_CASE(reducemean_keepdims_test)
2304
2305
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2306
2307
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2308
    mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2309
    auto prog = optimize_onnx("reducemean_keepdims_test.onnx");
2310
2311
2312
2313

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2314
2315
2316
TEST_CASE(reducemin_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2317
2318
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2319
2320
    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
2321
    auto prog = optimize_onnx("reducemin_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2322
2323
2324
2325

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2326
2327
2328
TEST_CASE(reduceprod_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2329
2330
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2331
    mm->add_instruction(migraphx::make_op("reduce_prod", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2332
2333
2334
2335
2336
    auto prog = optimize_onnx("reduceprod_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2337
TEST_CASE(reducesum_test)
Khalique's avatar
Khalique committed
2338
2339
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2340
2341
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2342
2343
    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
2344
    auto prog = optimize_onnx("reducesum_test.onnx");
2345
2346

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

Khalique's avatar
Khalique committed
2349
TEST_CASE(reducesum_multiaxis_test)
Khalique's avatar
Khalique committed
2350
2351
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2352
2353
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2354
2355
    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
2356
    auto prog = optimize_onnx("reducesum_multiaxis_test.onnx");
2357
2358

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

Khalique's avatar
Khalique committed
2361
TEST_CASE(reducesum_keepdims_test)
Khalique's avatar
Khalique committed
2362
2363
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2364
2365
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2366
    mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {2, 3}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2367
    auto prog = optimize_onnx("reducesum_keepdims_test.onnx");
2368
2369
2370
2371

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2372
2373
2374
TEST_CASE(reducesum_square_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2375
2376
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2377
2378
2379
    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
2380
2381
2382
2383
2384
    auto prog = optimize_onnx("reducesum_square_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2385
TEST_CASE(reshape_test)
2386
{
Khalique's avatar
Khalique committed
2387
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2388
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2389
2390
    migraphx::op::reshape op;
    std::vector<int64_t> reshape_dims{3, 8};
Shucai Xiao's avatar
Shucai Xiao committed
2391
    mm->add_literal(
Khalique's avatar
Khalique committed
2392
        migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, reshape_dims});
Shucai Xiao's avatar
Shucai Xiao committed
2393
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {4, 2, 3}});
Khalique's avatar
Khalique committed
2394
    op.dims = reshape_dims;
Shucai Xiao's avatar
Shucai Xiao committed
2395
2396
    mm->add_instruction(op, l0);
    mm->add_instruction(op, l0);
Shucai Xiao's avatar
Shucai Xiao committed
2397
    auto prog = optimize_onnx("reshape_test.onnx");
2398
2399

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

Khalique's avatar
Khalique committed
2402
TEST_CASE(reshape_non_standard_test)
2403
2404
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2405
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2406
2407
2408
    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
2409
    auto x      = mm->add_parameter("x", s);
2410
2411
2412
    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
2413
    auto prog = optimize_onnx("reshape_non_standard_test.onnx");
2414
2415
2416
2417

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2418
2419
2420
TEST_CASE(resize_downsample_f_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2421
    auto* mm              = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2422
2423
    std::vector<float> ds = {1.0f, 1.0f, 0.6f, 0.6f};
    migraphx::shape ss{migraphx::shape::float_type, {4}};
2424
    mm->add_literal(migraphx::literal{ss, ds});
Shucai Xiao's avatar
Shucai Xiao committed
2425
2426

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

2429
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2430
2431
2432

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

2435
2436
    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);
2437
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2438
2439
2440
2441
2442
2443
2444
2445
2446

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

    EXPECT(p == prog);
}

TEST_CASE(resize_downsample_c_test)
{
    migraphx::program p;
2447
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2448
2449
2450

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

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

2456
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2457
2458
2459

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

2462
2463
    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);
2464
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2465
2466
2467
2468
2469
2470
2471
2472
2473

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

    EXPECT(p == prog);
}

TEST_CASE(resize_outsize_test)
{
    migraphx::program p;
2474
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2475
2476
2477

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

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

2483
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2484
2485
2486

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

2489
2490
    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);
2491
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2492
2493
2494
2495
2496
2497
2498
2499
2500

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

    EXPECT(p == prog);
}

TEST_CASE(resize_upsample_pc_test)
{
    migraphx::program p;
2501
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2502
2503
2504

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

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

2510
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2511
2512
2513

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

2516
2517
    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);
2518
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2519
2520
2521
2522
2523
2524
2525
2526
2527

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

    EXPECT(p == prog);
}

TEST_CASE(resize_upsample_pf_test)
{
    migraphx::program p;
2528
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2529
2530
2531

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

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

2537
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2538
2539
2540

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

2543
2544
    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);
2545
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2546
2547
2548
2549
2550
2551

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

    EXPECT(p == prog);
}

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

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

Shucai Xiao's avatar
Shucai Xiao committed
2563
2564
2565
TEST_CASE(selu_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2566
    auto* mm                      = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2567
2568
    std::vector<std::size_t> lens = {2, 3};
    migraphx::shape s{migraphx::shape::double_type, lens};
Shucai Xiao's avatar
Shucai Xiao committed
2569
    auto x = mm->add_parameter("x", s);
Shucai Xiao's avatar
Shucai Xiao committed
2570
2571

    migraphx::shape ls{migraphx::shape::double_type, {1}};
2572
2573
2574
2575
2576
2577
    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
2578

2579
2580
    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
2581

2582
2583
    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
2584

2585
2586
    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
2587

2588
2589
2590
    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
2591
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2592
2593
2594
2595
2596
2597

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2598
TEST_CASE(shape_test)
2599
2600
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2601
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2602
    migraphx::shape s{migraphx::shape::float_type, {3, 4, 5, 6}};
Shucai Xiao's avatar
Shucai Xiao committed
2603
    auto l0 = mm->add_parameter("x", s);
Khalique's avatar
Khalique committed
2604
    migraphx::shape s_shape{migraphx::shape::int64_type, {4}};
Shucai Xiao's avatar
Shucai Xiao committed
2605
    mm->add_literal(s_shape, l0->get_shape().lens());
Shucai Xiao's avatar
Shucai Xiao committed
2606
    auto prog = optimize_onnx("shape_test.onnx");
2607
2608
2609
2610

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2611
TEST_CASE(shape_gather_test)
2612
2613
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2614
2615
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {7, 3, 10}});
2616
    migraphx::shape const_shape{migraphx::shape::int32_type, {1}};
Shucai Xiao's avatar
Shucai Xiao committed
2617
    auto l2 = mm->add_literal(migraphx::literal{const_shape, {1}});
Khalique's avatar
Khalique committed
2618
    auto l1 =
Shucai Xiao's avatar
Shucai Xiao committed
2619
        mm->add_literal(migraphx::shape{migraphx::shape::int64_type, {3}}, l0->get_shape().lens());
Khalique's avatar
Khalique committed
2620
    int axis = 0;
2621
    mm->add_instruction(migraphx::make_op("gather", {{"axis", axis}}), l1, l2);
Shucai Xiao's avatar
Shucai Xiao committed
2622
    auto prog = optimize_onnx("shape_gather_test.onnx");
2623
2624
2625
2626

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2627
TEST_CASE(sign_test)
Khalique's avatar
Khalique committed
2628
2629
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2630
2631
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
2632
    mm->add_instruction(migraphx::make_op("sign"), input);
Khalique's avatar
Khalique committed
2633

Shucai Xiao's avatar
Shucai Xiao committed
2634
    auto prog = optimize_onnx("sign_test.onnx");
Khalique's avatar
Khalique committed
2635
2636
2637
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2638
TEST_CASE(sin_test)
2639
2640
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2641
2642
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
2643
    mm->add_instruction(migraphx::make_op("sin"), input);
2644

Shucai Xiao's avatar
Shucai Xiao committed
2645
    auto prog = optimize_onnx("sin_test.onnx");
2646
2647
2648
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2649
TEST_CASE(sinh_test)
2650
2651
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2652
2653
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
2654
    mm->add_instruction(migraphx::make_op("sinh"), input);
Khalique's avatar
Khalique committed
2655

Shucai Xiao's avatar
Shucai Xiao committed
2656
    auto prog = optimize_onnx("sinh_test.onnx");
2657
2658
2659
2660

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
2661
2662
2663
TEST_CASE(slice_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2664
2665
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 2}});
2666
2667
    mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {1, 0}}, {"ends", {2, 2}}}), l0);
kahmed10's avatar
kahmed10 committed
2668
2669
2670
2671
2672
2673
2674
2675
    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
2676
2677
2678
2679
    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}});
2680
2681
    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
2682
    mm->add_return({ret});
kahmed10's avatar
kahmed10 committed
2683
2684
2685
2686
2687
2688

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2689
2690
2691
TEST_CASE(slice_5arg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2692
2693
2694
2695
2696
2697
    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}});
2698
2699
2700
    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
2701
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
2702
2703
2704
2705
2706
2707

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

    EXPECT(p == prog);
}

2708
2709
2710
TEST_CASE(slice_max_end_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2711
2712
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {10, 20}});
2713
2714
2715
2716
    mm->add_instruction(
        migraphx::make_op("slice",
                          {{"axes", {0, 1}}, {"starts", {1, 2}}, {"ends", {3000000000, -1}}}),
        l0);
2717
2718
2719
2720
2721
    auto prog = optimize_onnx("slice_max_end_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2722
TEST_CASE(softmax_test)
Shucai Xiao's avatar
Shucai Xiao committed
2723
2724
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2725
2726
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
2727
    mm->add_instruction(migraphx::make_op("softmax", {{"axis", 1}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2728
    auto prog = optimize_onnx("softmax_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2729
2730
2731
2732

    EXPECT(p == prog);
}

2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
TEST_CASE(softmax_nonstd_input_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {6, 8}});
    auto l1  = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {1, 0}}, {"ends", {4, 4}}}), l0);
    auto l2 = mm->add_instruction(migraphx::make_op("softmax", {{"axis", 1}}), l1);
    mm->add_return({l2});

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2748
2749
2750
TEST_CASE(split_minus_axis_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2751
2752
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2753
2754
2755
2756
2757
2758
    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
2759
    mm->add_return({r1, r2, r3});
Shucai Xiao's avatar
Shucai Xiao committed
2760
2761
2762
2763
2764
2765

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

    EXPECT(p == prog);
}

2766
2767
2768
TEST_CASE(split_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2769
2770
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2771
2772
2773
2774
2775
2776
    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
2777
    mm->add_return({r1, r2, r3});
2778
2779
2780
2781
2782
2783
2784
2785

    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
2786
2787
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2788
2789
2790
2791
    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
2792
    mm->add_return({r1, r2});
2793
2794
2795
2796
2797

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

Khalique's avatar
Khalique committed
2798
TEST_CASE(sqrt_test)
Shucai Xiao's avatar
Shucai Xiao committed
2799
2800
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2801
2802
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
2803
    mm->add_instruction(migraphx::make_op("sqrt"), input);
Shucai Xiao's avatar
Shucai Xiao committed
2804

Shucai Xiao's avatar
Shucai Xiao committed
2805
    auto prog = optimize_onnx("sqrt_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2806
2807
2808
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2809
TEST_CASE(squeeze_unsqueeze_test)
Khalique's avatar
Khalique committed
2810
2811
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2812
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2813
2814
2815
    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
2816
        mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 1, 1, 2, 1}});
2817
2818
    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
2819
    auto prog = optimize_onnx("squeeze_unsqueeze_test.onnx");
Khalique's avatar
Khalique committed
2820
2821
2822
2823

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2824
TEST_CASE(sub_bcast_test)
Shucai Xiao's avatar
Shucai Xiao committed
2825
2826
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2827
2828
2829
    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}});
2830
2831
2832
    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
2833

Shucai Xiao's avatar
Shucai Xiao committed
2834
    auto prog = optimize_onnx("sub_bcast_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2835
2836
2837
2838

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2839
TEST_CASE(sub_scalar_test)
Shucai Xiao's avatar
Shucai Xiao committed
2840
2841
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2842
2843
2844
    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}});
2845
2846
2847
    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
2848
    auto prog = optimize_onnx("sub_scalar_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2849
2850
2851
2852

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2853
2854
2855
TEST_CASE(sum_int_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2856
2857
2858
2859
    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}});
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
    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
2870
2871
2872
2873
2874

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

Khalique's avatar
Khalique committed
2875
TEST_CASE(sum_test)
2876
2877
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2878
2879
2880
2881
    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}});
2882
2883
    auto l0     = mm->add_instruction(migraphx::make_op("add"), input0, input1);
    mm->add_instruction(migraphx::make_op("add"), l0, input2);
2884

Shucai Xiao's avatar
Shucai Xiao committed
2885
    auto prog = optimize_onnx("sum_test.onnx");
2886
2887
2888
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2889
2890
2891
TEST_CASE(sum_type_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2892
2893
2894
2895
2896
2897
2898
2899
2900
    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}});
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
    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
2932
    mm->add_return({s6});
Shucai Xiao's avatar
Shucai Xiao committed
2933
2934
2935
2936
2937
2938

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2939
TEST_CASE(tan_test)
2940
2941
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2942
2943
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
2944
    mm->add_instruction(migraphx::make_op("tan"), input);
2945

Shucai Xiao's avatar
Shucai Xiao committed
2946
    auto prog = optimize_onnx("tan_test.onnx");
2947
2948
2949
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2950
TEST_CASE(tanh_test)
2951
2952
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2953
2954
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}});
2955
    mm->add_instruction(migraphx::make_op("tanh"), input);
2956

Shucai Xiao's avatar
Shucai Xiao committed
2957
    auto prog = optimize_onnx("tanh_test.onnx");
2958
2959
2960
2961

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
2962
2963
2964
TEST_CASE(tile_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2965
2966
2967
    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}});
2968
    mm->add_instruction(migraphx::make_op("concat", {{"axis", 1}}), input, input);
kahmed10's avatar
kahmed10 committed
2969
2970
2971
2972
2973
2974
2975
2976
2977

    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
2978
2979
2980
    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}});
2981
2982
2983
    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
2984
2985
2986
2987
2988
2989

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2990
TEST_CASE(transpose_test)
2991
2992
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2993
2994
    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
2995
    std::vector<int64_t> perm{0, 3, 1, 2};
2996
    mm->add_instruction(migraphx::make_op("transpose", {{"dims", perm}}), input);
Khalique's avatar
Khalique committed
2997

Shucai Xiao's avatar
Shucai Xiao committed
2998
    auto prog = optimize_onnx("transpose_test.onnx");
2999
3000
3001
3002

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3003
TEST_CASE(transpose_gather_test)
3004
3005
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3006
3007
    auto* mm             = p.get_main_module();
    auto make_contiguous = [&mm](migraphx::instruction_ref ins) {
Khalique's avatar
Khalique committed
3008
3009
3010
3011
3012
        if(ins->get_shape().standard())
        {
            return ins;
        }

3013
        return mm->add_instruction(migraphx::make_op("contiguous"), ins);
Khalique's avatar
Khalique committed
3014
3015
    };

Shucai Xiao's avatar
Shucai Xiao committed
3016
3017
    auto data =
        mm->add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 5, 4, 6}});
Khalique's avatar
Khalique committed
3018
    auto ind =
Shucai Xiao's avatar
Shucai Xiao committed
3019
        mm->add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 4, 3, 5}});
3020
3021
3022
3023
3024
3025
3026
3027
    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
3028

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

3031
    EXPECT(p.sort() == prog.sort());
3032
3033
}

3034
3035
3036
TEST_CASE(undefined_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3037
3038
    auto* mm = p.get_main_module();
    mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
3039
3040
    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
3041
    mm->add_return({l2});
3042
3043
3044
3045
3046
3047

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3048
TEST_CASE(unknown_test)
3049
3050
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3051
3052
3053
3054
3055
    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
3056
    auto prog = optimize_onnx("unknown_test.onnx");
3057
3058
3059
3060

    EXPECT(p == prog);
}

3061
3062
3063
3064
3065
TEST_CASE(unknown_aten_test)
{
    EXPECT(test::throws([&] { migraphx::parse_onnx("unknown_aten_test.onnx"); }));
}

3066
3067
3068
3069
3070
TEST_CASE(unknown_test_throw)
{
    EXPECT(test::throws([&] { migraphx::parse_onnx("unknown_test.onnx"); }));
}

Shucai Xiao's avatar
Shucai Xiao committed
3071
3072
3073
TEST_CASE(upsample_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3074
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
3075
    migraphx::shape ss{migraphx::shape::float_type, {4}};
Shucai Xiao's avatar
Shucai Xiao committed
3076
    mm->add_literal(migraphx::literal(ss, {1.0f, 1.0f, 2.0f, 3.0f}));
Shucai Xiao's avatar
Shucai Xiao committed
3077
3078

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
Shucai Xiao's avatar
Shucai Xiao committed
3079
    auto ix = mm->add_parameter("X", sx);
Shucai Xiao's avatar
Shucai Xiao committed
3080
3081
3082
3083

    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
3084
    auto li  = mm->add_literal(migraphx::literal(si, ind));
3085
3086
    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
3087
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
3088
3089
3090
3091
3092
3093

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

    EXPECT(p == prog);
}

3094
3095
3096
3097
3098
3099
3100
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); }));
}

3101
3102
3103
TEST_CASE(variable_batch_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3104
3105
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
3106
    mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
3107
    auto prog = optimize_onnx("variable_batch_test.onnx");
3108
3109
3110
3111

    EXPECT(p == prog);
}

3112
3113
3114
TEST_CASE(variable_batch_user_input_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3115
3116
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 16, 16}});
3117
    auto r   = mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
3118
    mm->add_return({r});
3119
3120
3121
3122
3123
3124
3125
3126
3127

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

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

    EXPECT(p == prog);
}

3128
3129
3130
TEST_CASE(variable_batch_leq_zero_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3131
3132
3133
    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}});
3134
    mm->add_instruction(migraphx::make_op("add"), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
3135
    auto prog = optimize_onnx("variable_batch_leq_zero_test.onnx");
3136
3137
3138
3139

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
3140
3141
3142
TEST_CASE(where_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3143
3144
3145
3146
3147
    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}});

3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
    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
3162
3163
3164
3165
3166
3167
3168
3169
3170

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

3171
3172
3173
    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
3174
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
3175
3176
3177
3178
3179
3180

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

    EXPECT(p == prog);
}

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