onnx_test.cpp 164 KB
Newer Older
Scott Thornton's avatar
Scott Thornton committed
1
#include <iostream>
Shucai Xiao's avatar
Shucai Xiao committed
2
#include <fstream>
Scott Thornton's avatar
Scott Thornton committed
3
#include <vector>
4
#include <migraphx/common.hpp>
Paul's avatar
Paul committed
5
6
7
#include <migraphx/literal.hpp>
#include <migraphx/program.hpp>
#include <migraphx/instruction.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
8
#include <migraphx/instruction_ref.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
9
10
#include <migraphx/pass_manager.hpp>
#include <migraphx/dead_code_elimination.hpp>
turneram's avatar
turneram committed
11
#include <migraphx/rewrite_quantization.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
12
#include <migraphx/eliminate_identity.hpp>
Paul's avatar
Paul committed
13
#include <migraphx/onnx.hpp>
14
#include <migraphx/make_op.hpp>
turneram's avatar
turneram committed
15
16
17
18
19
20
#include <migraphx/op/convolution.hpp>
#include <migraphx/op/pad.hpp>
#include <migraphx/op/pooling.hpp>
#include <migraphx/op/lrn.hpp>
#include <migraphx/op/reshape.hpp>
#include <migraphx/op/unknown.hpp>
21
22
23

#include <migraphx/serialize.hpp>

Scott Thornton's avatar
Scott Thornton committed
24
25
#include "test.hpp"

turneram's avatar
turneram committed
26
migraphx::program optimize_onnx(const std::string& name, bool run_passes = false)
Shucai Xiao's avatar
Shucai Xiao committed
27
{
28
29
30
    migraphx::onnx_options options;
    options.skip_unknown_operators = true;
    auto prog                      = migraphx::parse_onnx(name, options);
31
    auto* mm                       = prog.get_main_module();
turneram's avatar
turneram committed
32
33
34
    if(run_passes)
        migraphx::run_passes(*mm,
                             {migraphx::rewrite_quantization{}, migraphx::dead_code_elimination{}});
Shucai Xiao's avatar
Shucai Xiao committed
35
36

    // remove the last identity instruction
37
    auto last_ins = std::prev(mm->end());
38
    if(last_ins->name() == "@return")
Shucai Xiao's avatar
Shucai Xiao committed
39
    {
40
        mm->remove_instruction(last_ins);
Shucai Xiao's avatar
Shucai Xiao committed
41
42
43
44
45
    }

    return prog;
}

Khalique's avatar
Khalique committed
46
TEST_CASE(acos_test)
Scott Thornton's avatar
Scott Thornton committed
47
{
Paul's avatar
Paul committed
48
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
49
50
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
51
    mm->add_instruction(migraphx::make_op("acos"), input);
Scott Thornton's avatar
Scott Thornton committed
52

Shucai Xiao's avatar
Shucai Xiao committed
53
    auto prog = optimize_onnx("acos_test.onnx");
Scott Thornton's avatar
Scott Thornton committed
54
55
56
57

    EXPECT(p == prog);
}

58
59
60
TEST_CASE(acosh_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
61
62
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
63
    mm->add_instruction(migraphx::make_op("acosh"), input);
64
65
66
67
68
69

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
70
TEST_CASE(add_bcast_test)
71
{
Paul's avatar
Paul committed
72
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
73
74
75
    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}});
76
    auto l2  = mm->add_instruction(
77
        migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", l0->get_shape().lens()}}), l1);
78
    mm->add_instruction(migraphx::make_op("add"), l0, l2);
Paul's avatar
Paul committed
79

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

82
83
84
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
85
TEST_CASE(add_fp16_test)
Scott Thornton's avatar
Scott Thornton committed
86
{
Paul's avatar
Paul committed
87
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
88
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
89
    auto l0 =
Shucai Xiao's avatar
Shucai Xiao committed
90
        mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type, {1}}, {1.5}});
Khalique's avatar
Khalique committed
91
    auto l1 =
Shucai Xiao's avatar
Shucai Xiao committed
92
        mm->add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type, {1}}, {2.5}});
93
    mm->add_instruction(migraphx::make_op("add"), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
94
    auto prog = optimize_onnx("add_fp16_test.onnx");
Scott Thornton's avatar
Scott Thornton committed
95
96
97
98

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
99
TEST_CASE(add_scalar_test)
100
{
Paul's avatar
Paul committed
101
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
102
103
104
    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});
105
106
    auto m1 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 4, 5}}}), l1);
107
    auto r = mm->add_instruction(migraphx::make_op("add"), l0, m1);
Shucai Xiao's avatar
Shucai Xiao committed
108
    mm->add_return({r});
109
    auto prog = migraphx::parse_onnx("add_scalar_test.onnx");
110
111
112
113

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
114
TEST_CASE(argmax_test)
Khalique's avatar
Khalique committed
115
{
Paul's avatar
Paul committed
116
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
117
118
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
119
120
    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
121
    auto prog = optimize_onnx("argmax_test.onnx");
Khalique's avatar
Khalique committed
122
123
124
125

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
126
TEST_CASE(argmin_test)
127
{
Paul's avatar
Paul committed
128
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
129
130
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
131
132
    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
133
    auto prog = optimize_onnx("argmin_test.onnx");
134
135
136
137

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
138
TEST_CASE(asin_test)
139
{
Paul's avatar
Paul committed
140
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
141
142
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
143
    mm->add_instruction(migraphx::make_op("asin"), input);
144

Shucai Xiao's avatar
Shucai Xiao committed
145
    auto prog = optimize_onnx("asin_test.onnx");
146
147
148
149

    EXPECT(p == prog);
}

150
151
152
TEST_CASE(asinh_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
153
154
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
155
    mm->add_instruction(migraphx::make_op("asinh"), input);
156
157
158
159
160
161

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
162
TEST_CASE(atan_test)
Khalique's avatar
Khalique committed
163
{
Paul's avatar
Paul committed
164
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
165
166
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
167
    mm->add_instruction(migraphx::make_op("atan"), input);
Khalique's avatar
Khalique committed
168

Shucai Xiao's avatar
Shucai Xiao committed
169
    auto prog = optimize_onnx("atan_test.onnx");
Khalique's avatar
Khalique committed
170
171
172
173

    EXPECT(p == prog);
}

174
175
176
TEST_CASE(atanh_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
177
178
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
179
    mm->add_instruction(migraphx::make_op("atanh"), input);
180
181
182
183
184
185

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

    EXPECT(p == prog);
}

186
187
188
TEST_CASE(averagepool_1d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
189
190
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 5}});
191
192
    mm->add_instruction(
        migraphx::make_op(
kahmed10's avatar
kahmed10 committed
193
194
            "pooling",
            {{"mode", "average"}, {"padding", {0, 0}}, {"stride", {1}}, {"lengths", {3}}}),
195
        l0);
196
197
198
199
200
201
202
203

    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
204
205
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::float_type, {1, 3, 5, 5, 5}});
206
207
    mm->add_instruction(migraphx::make_op("pooling",
                                          {{"mode", "average"},
kahmed10's avatar
kahmed10 committed
208
                                           {"padding", {0, 0, 0, 0, 0, 0}},
209
210
211
                                           {"stride", {1, 1, 1}},
                                           {"lengths", {3, 3, 3}}}),
                        l0);
212
213
214
215
216

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

217
TEST_CASE(averagepool_notset_test)
218
219
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
220
221
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
kahmed10's avatar
kahmed10 committed
222
223
224
225
226
227
228
    auto ins   = mm->add_instruction(migraphx::make_op("pooling",
                                                     {{"mode", "average"},
                                                      {"padding", {2, 2, 2, 2}},
                                                      {"stride", {2, 2}},
                                                      {"lengths", {6, 6}}}),
                                   input);
    auto ret   = mm->add_instruction(
229
        migraphx::make_op("slice", {{"axes", {2, 3}}, {"starts", {1, 1}}, {"ends", {2, 2}}}), ins);
Shucai Xiao's avatar
Shucai Xiao committed
230
    mm->add_return({ret});
231
232
233
234
235
236
    auto prog = migraphx::parse_onnx("averagepool_notset_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(averagepool_nt_cip_test)
237
238
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
239
240
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
241
    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
242
    auto ins_pad = mm->add_instruction(migraphx::make_op("pad", {{"pads", pads}}), input);
kahmed10's avatar
kahmed10 committed
243
244
245
246
247
248
    auto ret     = mm->add_instruction(migraphx::make_op("pooling",
                                                     {{"mode", "average"},
                                                      {"padding", {0, 0, 0, 0}},
                                                      {"stride", {2, 2}},
                                                      {"lengths", {6, 6}}}),
                                   ins_pad);
Shucai Xiao's avatar
Shucai Xiao committed
249
    mm->add_return({ret});
250

251
    auto prog = migraphx::parse_onnx("averagepool_nt_cip_test.onnx");
252
253
254
255
    EXPECT(p == prog);
}

TEST_CASE(averagepool_same_lower_test)
256
257
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
258
259
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
kahmed10's avatar
kahmed10 committed
260
261
262
263
264
265
266
    auto ins   = mm->add_instruction(migraphx::make_op("pooling",
                                                     {{"mode", "average"},
                                                      {"padding", {1, 1, 1, 1}},
                                                      {"stride", {1, 1}},
                                                      {"lengths", {2, 2}}}),
                                   input);
    auto ret   = mm->add_instruction(
267
        migraphx::make_op("slice", {{"axes", {2, 3}}, {"starts", {0, 0}}, {"ends", {5, 5}}}), ins);
Shucai Xiao's avatar
Shucai Xiao committed
268
    mm->add_return({ret});
269
270
271
272
273
274
    auto prog = migraphx::parse_onnx("averagepool_same_lower_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(averagepool_sl_cip_test)
275
276
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
277
278
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
279
    std::vector<int64_t> pads = {0, 0, 1, 1, 0, 0, 0, 0};
280
    auto ins_pad = mm->add_instruction(migraphx::make_op("pad", {{"pads", pads}}), input);
kahmed10's avatar
kahmed10 committed
281
282
283
284
285
286
    auto ret     = mm->add_instruction(migraphx::make_op("pooling",
                                                     {{"mode", "average"},
                                                      {"padding", {0, 0, 0, 0}},
                                                      {"stride", {1, 1}},
                                                      {"lengths", {2, 2}}}),
                                   ins_pad);
Shucai Xiao's avatar
Shucai Xiao committed
287
    mm->add_return({ret});
288
    auto prog = migraphx::parse_onnx("averagepool_sl_cip_test.onnx");
289
290
291
292
293
294
295

    EXPECT(p == prog);
}

TEST_CASE(averagepool_same_upper_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
296
297
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
kahmed10's avatar
kahmed10 committed
298
299
300
301
302
303
304
    auto ins   = mm->add_instruction(migraphx::make_op("pooling",
                                                     {{"mode", "average"},
                                                      {"padding", {1, 1, 1, 1}},
                                                      {"stride", {1, 1}},
                                                      {"lengths", {2, 2}}}),
                                   input);
    auto ret   = mm->add_instruction(
305
        migraphx::make_op("slice", {{"axes", {2, 3}}, {"starts", {1, 1}}, {"ends", {6, 6}}}), ins);
Shucai Xiao's avatar
Shucai Xiao committed
306
    mm->add_return({ret});
307
    auto prog = migraphx::parse_onnx("averagepool_same_upper_test.onnx");
308
309
310
311

    EXPECT(p == prog);
}

312
313
314
TEST_CASE(batchnorm_1d_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}});
    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
327
328
329

    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
330
331
332
333
334
335
    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}});
336
    mm->add_instruction(migraphx::make_op("batch_norm_inference"), l0, l1, l2, l3, l4);
337
338
339
340
341

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

Khalique's avatar
Khalique committed
342
TEST_CASE(cast_test)
Khalique's avatar
Khalique committed
343
{
Paul's avatar
Paul committed
344
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
345
346
    auto* mm = p.get_main_module();
    auto l   = mm->add_parameter("x", migraphx::shape{migraphx::shape::half_type, {10}});
347
348
349
350
    mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
        l);
Khalique's avatar
Khalique committed
351

Shucai Xiao's avatar
Shucai Xiao committed
352
    auto prog = optimize_onnx("cast_test.onnx");
Khalique's avatar
Khalique committed
353
354
355
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
356
357
358
TEST_CASE(ceil_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
359
360
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
361
    mm->add_instruction(migraphx::make_op("ceil"), input);
Shucai Xiao's avatar
Shucai Xiao committed
362

Shucai Xiao's avatar
Shucai Xiao committed
363
    auto prog = optimize_onnx("ceil_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
364
365
366
367

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
368
TEST_CASE(clip_test)
Khalique's avatar
Khalique committed
369
370
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
371
372
373
374
    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);
375
    min_val =
376
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3}}}), min_val);
377
    max_val =
378
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3}}}), max_val);
379
    mm->add_instruction(migraphx::make_op("clip"), l0, min_val, max_val);
Shucai Xiao's avatar
Shucai Xiao committed
380
    auto prog = optimize_onnx("clip_test.onnx");
Khalique's avatar
Khalique committed
381

382
383
384
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
385
386
387
TEST_CASE(clip_test_op11_max_only)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
388
389
390
    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}});
391
392
    mm->add_instruction(migraphx::make_op("undefined"));
    max_val =
393
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3}}}), max_val);
394
    auto r = mm->add_instruction(migraphx::make_op("min"), l0, max_val);
Shucai Xiao's avatar
Shucai Xiao committed
395
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
396
397
398
399
400
401

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
402
403
404
TEST_CASE(clip_test_op11)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
405
406
407
408
    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}});
409
    min_val =
410
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3}}}), min_val);
411
    max_val =
412
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3}}}), max_val);
413
    mm->add_instruction(migraphx::make_op("clip"), l0, min_val, max_val);
kahmed10's avatar
kahmed10 committed
414
415
416
417
418
419
420
421
    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
422
423
424
    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}});
425
    min_val =
426
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3}}}), min_val);
427
    mm->add_instruction(migraphx::make_op("max"), l0, min_val);
kahmed10's avatar
kahmed10 committed
428
429
430
431
432
433
434
435
    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
436
437
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
438
    mm->add_instruction(migraphx::make_op("identity"), l0);
kahmed10's avatar
kahmed10 committed
439
440
441
442
443
    auto prog = optimize_onnx("clip_test_op11_no_args.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
444
445
446
TEST_CASE(clip_test_op11_no_args1)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
447
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
448

Shucai Xiao's avatar
Shucai Xiao committed
449
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
450
451
    mm->add_instruction(migraphx::make_op("undefined"));
    auto r = mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
452
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
453
454
455
456
457
    auto prog = migraphx::parse_onnx("clip_test_op11_no_args1.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
458
TEST_CASE(concat_test)
Shucai Xiao's avatar
Shucai Xiao committed
459
460
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
461
462
463
    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}});
464
    mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
465
    auto prog = optimize_onnx("concat_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
466
467
468
469

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
470
TEST_CASE(constant_test)
Shucai Xiao's avatar
Shucai Xiao committed
471
472
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
473
474
475
    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
476
    auto prog = optimize_onnx("constant_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
477
478
479
480

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
481
TEST_CASE(constant_fill_test)
Shucai Xiao's avatar
Shucai Xiao committed
482
{
Khalique's avatar
Khalique committed
483
484

    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
485
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
486
487
    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
    std::vector<float> value(s.elements(), 1.0);
Shucai Xiao's avatar
Shucai Xiao committed
488
    mm->add_literal(migraphx::literal{s, value});
Shucai Xiao's avatar
Shucai Xiao committed
489
    auto prog = optimize_onnx("constant_fill_test.onnx");
Khalique's avatar
Khalique committed
490
491
492
493
494
495
496

    EXPECT(p == prog);
}

TEST_CASE(constant_fill_input_as_shape_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
497
498
    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
499
500
501
502
503
    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
504
    mm->add_literal(migraphx::literal{s, value});
Shucai Xiao's avatar
Shucai Xiao committed
505
    auto prog = optimize_onnx("constant_fill_input_as_shape_test.onnx");
Khalique's avatar
Khalique committed
506
507

    EXPECT(p == prog);
Shucai Xiao's avatar
Shucai Xiao committed
508
509
}

Khalique's avatar
Khalique committed
510
TEST_CASE(constant_scalar_test)
511
512
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
513
514
    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
515
    auto prog = optimize_onnx("constant_scalar_test.onnx");
516
517
518
519

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
520
TEST_CASE(const_of_shape_empty_input_test)
Shucai Xiao's avatar
Shucai Xiao committed
521
522
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
523
524
    auto* mm = p.get_main_module();
    mm->add_literal(migraphx::literal());
Khalique's avatar
Khalique committed
525
526
    migraphx::shape s(migraphx::shape::int64_type, {1}, {0});
    std::vector<int64_t> vec(s.elements(), 10);
Shucai Xiao's avatar
Shucai Xiao committed
527
    mm->add_literal(migraphx::literal(s, vec));
Shucai Xiao's avatar
Shucai Xiao committed
528

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

Khalique's avatar
Khalique committed
533
TEST_CASE(const_of_shape_float_test)
534
535
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
536
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
537
    migraphx::shape ss(migraphx::shape::int32_type, {3});
Shucai Xiao's avatar
Shucai Xiao committed
538
    mm->add_literal(migraphx::literal(ss, {2, 3, 4}));
Khalique's avatar
Khalique committed
539
540
    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
541
    mm->add_literal(migraphx::literal(s, vec));
542

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

Khalique's avatar
Khalique committed
547
TEST_CASE(const_of_shape_int64_test)
548
549
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
550
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
551
    migraphx::shape ss(migraphx::shape::int32_type, {3});
Shucai Xiao's avatar
Shucai Xiao committed
552
    mm->add_literal(migraphx::literal(ss, {2, 3, 4}));
Khalique's avatar
Khalique committed
553
554
    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
555
    mm->add_literal(migraphx::literal(s, vec));
556

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

Khalique's avatar
Khalique committed
561
TEST_CASE(const_of_shape_no_value_attr_test)
562
563
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
564
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
565
    migraphx::shape ss(migraphx::shape::int32_type, {3});
Shucai Xiao's avatar
Shucai Xiao committed
566
    mm->add_literal(migraphx::literal(ss, {2, 3, 4}));
Khalique's avatar
Khalique committed
567
568
    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
569
    mm->add_literal(migraphx::literal(s, vec));
570

Shucai Xiao's avatar
Shucai Xiao committed
571
    auto prog = optimize_onnx("const_of_shape_no_value_attr_test.onnx");
572
573
574
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
575
TEST_CASE(conv_autopad_fail_test)
576
{
Shucai Xiao's avatar
Shucai Xiao committed
577
    EXPECT(test::throws([&] { optimize_onnx("conv_autopad_fail_test.onnx"); }));
Khalique's avatar
Khalique committed
578
}
579

580
581
582
TEST_CASE(conv_1d_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}});
    auto l1  = mm->add_parameter("1", {migraphx::shape::float_type, {1, 3, 3}});
586
587
588
589
    mm->add_instruction(
        migraphx::make_op("convolution", {{"padding", {0}}, {"stride", {1}}, {"dilation", {1}}}),
        l0,
        l1);
590
591
592
593
594
595
596
597

    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
598
599
600
    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}});
601
602
603
604
605
    mm->add_instruction(
        migraphx::make_op("convolution",
                          {{"padding", {0, 0, 0}}, {"stride", {1, 1, 1}}, {"dilation", {1, 1, 1}}}),
        l0,
        l1);
606
607
608
609
610
611
612
613
614
615

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

616
617
618
TEST_CASE(conv_autopad_same_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
619
620
621
    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}});
622
    migraphx::op::convolution op;
kahmed10's avatar
kahmed10 committed
623
    op.padding      = {1, 1, 1, 1};
624
    op.padding_mode = migraphx::op::padding_mode_t::same;
Shucai Xiao's avatar
Shucai Xiao committed
625
    mm->add_instruction(op, l0, l1);
626
627
628
629
630

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

Khalique's avatar
Khalique committed
631
632
633
TEST_CASE(conv_bias_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
634
635
636
637
    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
638
    uint64_t axis = 1;
639
640
    auto l3       = mm->add_instruction(migraphx::make_op("convolution"), l0, l1);
    auto l4       = mm->add_instruction(
641
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", l3->get_shape().lens()}}), l2);
642
    mm->add_instruction(migraphx::make_op("add"), l3, l4);
Khalique's avatar
Khalique committed
643

Shucai Xiao's avatar
Shucai Xiao committed
644
    auto prog = optimize_onnx("conv_bias_test.onnx");
Khalique's avatar
Khalique committed
645
646
647
648
649
650
    EXPECT(p == prog);
}

TEST_CASE(conv_bn_relu_maxpool_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
651
652
653
654
    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
655

Shucai Xiao's avatar
Shucai Xiao committed
656
657
658
659
    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
660
    uint64_t axis = 1;
kahmed10's avatar
kahmed10 committed
661
662
663
    auto l3 =
        mm->add_instruction(migraphx::make_op("convolution", {{"padding", {0, 0, 0, 0}}}), l0, l1);
    auto l4 = mm->add_instruction(
664
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", l3->get_shape().lens()}}), l2);
665
666
667
668
669
670
671
    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",
kahmed10's avatar
kahmed10 committed
672
            {{"mode", "max"}, {"padding", {0, 0, 0, 0}}, {"stride", {2, 2}}, {"lengths", {2, 2}}}),
673
        l7);
Khalique's avatar
Khalique committed
674

Shucai Xiao's avatar
Shucai Xiao committed
675
    auto prog = optimize_onnx("conv_bn_relu_maxpool_test.onnx");
Khalique's avatar
Khalique committed
676
677
678
679
680
681
    EXPECT(p == prog);
}

TEST_CASE(conv_relu_maxpool_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
682
683
684
685
    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
686
    uint64_t axis = 1;
kahmed10's avatar
kahmed10 committed
687
688
689
    auto l3 =
        mm->add_instruction(migraphx::make_op("convolution", {{"padding", {0, 0, 0, 0}}}), l0, l1);
    auto l4 = mm->add_instruction(
690
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", l3->get_shape().lens()}}), l2);
691
692
693
694
695
    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",
kahmed10's avatar
kahmed10 committed
696
            {{"mode", "max"}, {"padding", {0, 0, 0, 0}}, {"stride", {2, 2}}, {"lengths", {2, 2}}}),
697
        l6);
Khalique's avatar
Khalique committed
698

Shucai Xiao's avatar
Shucai Xiao committed
699
    auto prog = optimize_onnx("conv_relu_maxpool_test.onnx");
Khalique's avatar
Khalique committed
700
701
702
703
704
705
    EXPECT(p == prog);
}

TEST_CASE(conv_relu_maxpool_x2_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
706
707
708
709
    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
710
    uint64_t axis = 1;
kahmed10's avatar
kahmed10 committed
711
712
713
    auto l3 =
        mm->add_instruction(migraphx::make_op("convolution", {{"padding", {0, 0, 0, 0}}}), l0, l1);
    auto l4 = mm->add_instruction(
714
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", l3->get_shape().lens()}}), l2);
715
716
717
718
719
    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",
kahmed10's avatar
kahmed10 committed
720
            {{"mode", "max"}, {"padding", {0, 0, 0, 0}}, {"stride", {2, 2}}, {"lengths", {2, 2}}}),
721
        l6);
Shucai Xiao's avatar
Shucai Xiao committed
722

kahmed10's avatar
kahmed10 committed
723
724
725
726
    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}});
    auto l10 =
        mm->add_instruction(migraphx::make_op("convolution", {{"padding", {0, 0, 0, 0}}}), l7, l8);
727
    auto l11 = mm->add_instruction(
728
729
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", l10->get_shape().lens()}}),
        l9);
730
731
732
733
734
    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",
kahmed10's avatar
kahmed10 committed
735
            {{"mode", "max"}, {"padding", {0, 0, 0, 0}}, {"stride", {2, 2}}, {"lengths", {2, 2}}}),
736
        l13);
Khalique's avatar
Khalique committed
737

Shucai Xiao's avatar
Shucai Xiao committed
738
    auto prog = optimize_onnx("conv_relu_maxpool_x2_test.onnx");
Khalique's avatar
Khalique committed
739
740
741
742

    EXPECT(p == prog);
}

743
744
745
TEST_CASE(convinteger_bias_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
746
747
748
749
    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}});
750
    uint64_t axis = 1;
751
752
    auto l3       = mm->add_instruction(migraphx::make_op("quant_convolution"), l0, l1);
    auto l4       = mm->add_instruction(
753
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", l3->get_shape().lens()}}), l2);
754
    mm->add_instruction(migraphx::make_op("add"), l3, l4);
755
756
757
758
759

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

Khalique's avatar
Khalique committed
760
TEST_CASE(cos_test)
761
762
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
763
764
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
765
    mm->add_instruction(migraphx::make_op("cos"), input);
766

Shucai Xiao's avatar
Shucai Xiao committed
767
    auto prog = optimize_onnx("cos_test.onnx");
768
769
770
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
771
TEST_CASE(cosh_test)
772
773
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
774
775
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}});
776
    mm->add_instruction(migraphx::make_op("cosh"), input);
777

Shucai Xiao's avatar
Shucai Xiao committed
778
    auto prog = optimize_onnx("cosh_test.onnx");
779
780
781
782

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
783
784
785
TEST_CASE(deconv_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
786
787
788
    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}});
789
    mm->add_instruction(migraphx::make_op("deconvolution"), l0, l1);
kahmed10's avatar
kahmed10 committed
790
791
792
793
794
795
796
797

    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
798
799
800
801
    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
802
    uint64_t axis = 1;
803
804
    auto l3       = mm->add_instruction(migraphx::make_op("deconvolution"), l0, l1);
    auto l4       = mm->add_instruction(
805
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", l3->get_shape().lens()}}), l2);
806
    mm->add_instruction(migraphx::make_op("add"), l3, l4);
kahmed10's avatar
kahmed10 committed
807
808
809
810
811
812
813
814

    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
815
816
817
    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}});
818
819
    mm->add_instruction(
        migraphx::make_op("deconvolution", {{"padding", {1, 1}}, {"stride", {3, 2}}}), l0, l1);
kahmed10's avatar
kahmed10 committed
820
821
822
823
824
825
826
827

    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
828
829
830
    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}});
831
832
833
834
    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
835
836
837
838
839

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

kahmed10's avatar
kahmed10 committed
840
841
842
TEST_CASE(deconv_input_pads_asymm_1d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
843
844
845
    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}});
846
    auto l2  = mm->add_instruction(
kahmed10's avatar
kahmed10 committed
847
848
        migraphx::make_op("deconvolution",
                          {{"padding", {0, 0}}, {"stride", {2}}, {"dilation", {1}}}),
849
850
851
852
        l0,
        l1);
    mm->add_instruction(migraphx::make_op("slice", {{"axes", {2}}, {"starts", {0}}, {"ends", {6}}}),
                        l2);
kahmed10's avatar
kahmed10 committed
853
854
855
856
857
858

    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
859
860
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
861
862
863
    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}});
864
865
866
    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
867

kahmed10's avatar
kahmed10 committed
868
    auto prog = optimize_onnx("deconv_output_padding_test.onnx");
kahmed10's avatar
kahmed10 committed
869
870
871
    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
872
873
874
TEST_CASE(deconv_output_padding_3d_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
875
876
877
    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}});
878
879
880
881
882
883
    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
884
885
886
887
888
889

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

TEST_CASE(deconv_output_shape_test)
kahmed10's avatar
kahmed10 committed
890
891
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
892
893
894
    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}});
895
896
897
    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
898

kahmed10's avatar
kahmed10 committed
899
900
901
902
903
904
905
    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
906
907
908
    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}});
909
910
911
912
913
914
    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
915
916

    auto prog = optimize_onnx("deconv_output_shape_3d_test.onnx");
kahmed10's avatar
kahmed10 committed
917
918
919
    EXPECT(p == prog);
}

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
TEST_CASE(depthtospace_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 8, 5, 5}});
    auto tmp1 =
        mm->add_instruction(migraphx::make_op("reshape", {{"dims", {2, 2, 2, 2, 5, 5}}}), l0);
    auto tmp2 = mm->add_instruction(
        migraphx::make_op("transpose", {{"permutation", {0, 3, 4, 1, 5, 2}}}), tmp1);
    auto tmp3 = mm->add_instruction(migraphx::make_op("contiguous"), tmp2);
    mm->add_instruction(migraphx::make_op("reshape", {{"dims", {2, 2, 10, 10}}}), tmp3);
    auto prog = optimize_onnx("depthtospace_test.onnx");
    EXPECT(p == prog);
}

TEST_CASE(depthtospace_crd_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 8, 5, 5}});
    auto tmp1 =
        mm->add_instruction(migraphx::make_op("reshape", {{"dims", {2, 2, 2, 2, 5, 5}}}), l0);
    auto tmp2 = mm->add_instruction(
        migraphx::make_op("transpose", {{"permutation", {0, 1, 4, 2, 5, 3}}}), tmp1);
    auto tmp3 = mm->add_instruction(migraphx::make_op("contiguous"), tmp2);
    mm->add_instruction(migraphx::make_op("reshape", {{"dims", {2, 2, 10, 10}}}), tmp3);
    auto prog = optimize_onnx("depthtospace_crd_test.onnx");
    EXPECT(p == prog);
}

TEST_CASE(depthtospace_simple_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", {migraphx::shape::float_type, {1, 8, 2, 3}});
    auto tmp1 =
        mm->add_instruction(migraphx::make_op("reshape", {{"dims", {1, 2, 2, 2, 2, 3}}}), l0);
    auto tmp2 = mm->add_instruction(
        migraphx::make_op("transpose", {{"permutation", {0, 3, 4, 1, 5, 2}}}), tmp1);
    auto tmp3 = mm->add_instruction(migraphx::make_op("contiguous"), tmp2);
    mm->add_instruction(migraphx::make_op("reshape", {{"dims", {1, 2, 4, 6}}}), tmp3);
    auto prog = optimize_onnx("depthtospace_simple_test.onnx");
    EXPECT(p == prog);
}

965
966
967
968
969
970
971
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 l1_mbcast =
972
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {5}}}), l1);
turneram's avatar
turneram committed
973
    auto dequant = mm->add_instruction(
974
        migraphx::make_op("convert",
turneram's avatar
turneram committed
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
        l0);
    mm->add_instruction(migraphx::make_op("mul"), dequant, l1_mbcast);

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

TEST_CASE(dequantizelinear_zero_point_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 =
991
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {5}}}), l1);
992
    auto l2_mbcast =
993
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {5}}}), l2);
turneram's avatar
turneram committed
994
    l2_mbcast = mm->add_instruction(
995
        migraphx::make_op("convert",
turneram's avatar
turneram committed
996
997
998
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
        l2_mbcast);
    l0 = mm->add_instruction(
999
1000
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
turneram's avatar
turneram committed
1001
        l0);
1002

turneram's avatar
turneram committed
1003
1004
    auto sub = mm->add_instruction(migraphx::make_op("sub"), l0, l2_mbcast);
    mm->add_instruction(migraphx::make_op("mul"), sub, l1_mbcast);
1005

turneram's avatar
turneram committed
1006
    auto prog = optimize_onnx("dequantizelinear_zero_point_test.onnx", true);
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
    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(
1020
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", input_lens}}), l1);
1021
    auto l2_bcast = mm->add_instruction(
1022
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", input_lens}}), l2);
1023
1024
    l2_bcast = mm->add_instruction(
        migraphx::make_op("convert",
turneram's avatar
turneram committed
1025
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
1026
1027
1028
1029
        l2_bcast);
    l0 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
turneram's avatar
turneram committed
1030
1031
        l0);
    auto sub = mm->add_instruction(migraphx::make_op("sub"), l0, l2_bcast);
1032

turneram's avatar
turneram committed
1033
    mm->add_instruction(migraphx::make_op("mul"), sub, l1_bcast);
1034
1035
1036
1037
1038
1039
1040
    return p;
}

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

turneram's avatar
turneram committed
1041
    auto prog = optimize_onnx("dequantizelinear_axis_test.onnx", true);
1042
1043
1044
1045
1046
1047
1048
    EXPECT(p.sort() == prog.sort());
}

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

turneram's avatar
turneram committed
1049
    auto prog = optimize_onnx("dequantizelinear_neg_axis_test.onnx", true);
1050
1051
1052
    EXPECT(p.sort() == prog.sort());
}

Khalique's avatar
Khalique committed
1053
TEST_CASE(dropout_test)
Shucai Xiao's avatar
Shucai Xiao committed
1054
1055
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1056
1057
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}});
1058
    auto out   = mm->add_instruction(migraphx::make_op("identity"), input);
1059
1060
    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
1061
1062
    mm->add_literal(migraphx::literal(s, vec));
    mm->add_return({out});
Shucai Xiao's avatar
Shucai Xiao committed
1063

1064
    auto prog = migraphx::parse_onnx("dropout_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1065
1066
1067
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1068
1069
1070
TEST_CASE(elu_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1071
1072
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
1073
    mm->add_instruction(migraphx::make_op("elu", {{"alpha", 0.01}}), input);
Khalique's avatar
Khalique committed
1074

Shucai Xiao's avatar
Shucai Xiao committed
1075
    auto prog = optimize_onnx("elu_test.onnx");
Khalique's avatar
Khalique committed
1076
1077
1078
1079

    EXPECT(p == prog);
}

1080
1081
1082
TEST_CASE(embedding_bag_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1083
1084
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("weight", migraphx::shape{migraphx::shape::float_type, {4, 2}});
1085
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {3}}, {1, 0, 2}};
Shucai Xiao's avatar
Shucai Xiao committed
1086
1087
    auto l1 = mm->add_literal(l);
    mm->add_literal(0);
1088
1089
1090
1091
1092
1093
    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
1094
    mm->add_return({r1, r2, r3});
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105

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

1106
1107
1108
TEST_CASE(equal_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1109
    auto* mm = p.get_main_module();
1110
1111
1112
    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
1113
1114
    auto input1 = mm->add_literal(migraphx::literal(s, data));
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
1115
1116
1117
1118
1119
    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
1120
    mm->add_return({ret});
1121
1122
1123
1124
1125
1126
1127
1128
1129

    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
1130
    auto* mm = p.get_main_module();
1131
1132
1133
    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
1134
1135
    auto input1 = mm->add_parameter("x1", sf);
    auto input2 = mm->add_parameter("x2", sb);
1136
1137
1138
1139
1140
    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
1141
    mm->add_return({ret});
1142
1143
1144
1145
1146
1147

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1148
TEST_CASE(erf_test)
1149
1150
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1151
1152
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
1153
    mm->add_instruction(migraphx::make_op("erf"), input);
Khalique's avatar
Khalique committed
1154

Shucai Xiao's avatar
Shucai Xiao committed
1155
    auto prog = optimize_onnx("erf_test.onnx");
Khalique's avatar
Khalique committed
1156
1157
1158
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1159
TEST_CASE(exp_test)
1160
1161
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1162
1163
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
1164
    mm->add_instruction(migraphx::make_op("exp"), input);
Khalique's avatar
Khalique committed
1165

Shucai Xiao's avatar
Shucai Xiao committed
1166
    auto prog = optimize_onnx("exp_test.onnx");
Khalique's avatar
Khalique committed
1167
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
1168
1169
}

Khalique's avatar
Khalique committed
1170
TEST_CASE(expand_test)
1171
1172
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1173
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
1174
    migraphx::shape s(migraphx::shape::float_type, {3, 1, 1});
Shucai Xiao's avatar
Shucai Xiao committed
1175
    auto param = mm->add_parameter("x", s);
Khalique's avatar
Khalique committed
1176
    migraphx::shape ss(migraphx::shape::int32_type, {4});
Shucai Xiao's avatar
Shucai Xiao committed
1177
    mm->add_literal(migraphx::literal(ss, {2, 3, 4, 5}));
1178
    mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 4, 5}}}), param);
Khalique's avatar
Khalique committed
1179

Shucai Xiao's avatar
Shucai Xiao committed
1180
    auto prog = optimize_onnx("expand_test.onnx");
Khalique's avatar
Khalique committed
1181
    EXPECT(p == prog);
Khalique's avatar
Khalique committed
1182
1183
}

1184
1185
1186
migraphx::program create_external_data_prog()
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1187
    auto* mm = p.get_main_module();
1188
1189
1190
1191
    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
1192
    auto bias = mm->add_literal(migraphx::literal({migraphx::shape::float_type, {10}}, bias_data));
kahmed10's avatar
kahmed10 committed
1193
1194
1195
1196
    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", {{"padding", {0, 0, 0, 0}}}), param, weights);
Shucai Xiao's avatar
Shucai Xiao committed
1197
    auto bias_bcast = mm->add_instruction(
1198
        migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", {1, 10, 214, 214}}}), bias);
Shucai Xiao's avatar
Shucai Xiao committed
1199
    mm->add_instruction(migraphx::make_op("add"), conv, bias_bcast);
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
    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
1219
TEST_CASE(flatten_test)
1220
1221
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1222
1223
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
1224
1225
    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
1226
    auto prog = optimize_onnx("flatten_test.onnx");
1227
1228
1229
1230

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1231
1232
1233
1234
1235
TEST_CASE(flatten_nonstd_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 5, 4}});
1236
1237
1238
    auto l1 =
        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), l0);
    auto l2 = mm->add_instruction(migraphx::make_op("contiguous"), l1);
Khalique's avatar
Khalique committed
1239
1240
1241
1242
1243
1244
1245
1246
    mm->add_instruction(migraphx::make_op("flatten", {{"axis", 2}}), l2);
    auto l3 = mm->add_instruction(migraphx::make_op("contiguous"), l1);
    mm->add_instruction(migraphx::make_op("flatten", {{"axis", 1}}), l3);
    auto prog = optimize_onnx("flatten_nonstd_test.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1247
1248
1249
TEST_CASE(floor_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1250
1251
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
1252
    mm->add_instruction(migraphx::make_op("floor"), input);
Shucai Xiao's avatar
Shucai Xiao committed
1253

Shucai Xiao's avatar
Shucai Xiao committed
1254
    auto prog = optimize_onnx("floor_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1255
1256
1257
1258

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1259
TEST_CASE(gather_test)
1260
1261
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1262
1263
1264
    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
1265
    int axis = 1;
1266
    mm->add_instruction(migraphx::make_op("gather", {{"axis", axis}}), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1267
    auto prog = optimize_onnx("gather_test.onnx");
1268
1269
1270
1271

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1272
1273
1274
TEST_CASE(gather_elements_axis0_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1275
1276
1277
    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
1278
1279
1280
1281
    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
1282
        mm->add_literal(migraphx::literal{ind_s, ind_indices.begin(), ind_indices.end()});
Shucai Xiao's avatar
Shucai Xiao committed
1283
    auto l_ind_axis_indices =
Shucai Xiao's avatar
Shucai Xiao committed
1284
1285
        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
1286

1287
1288
    auto rsp_data    = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {12}}}), data);
    auto lbst_stride = mm->add_instruction(
1289
        migraphx::make_op("multibroadcast", {{"out_lens", ind_s.lens()}}), l_stride);
1290
1291
1292
1293
    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
1294
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1295
1296
1297
1298
1299
1300
1301
1302
1303

    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
1304
1305
1306
    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
1307
1308
1309
1310
    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
1311
        mm->add_literal(migraphx::literal{ind_s, ind_indices.begin(), ind_indices.end()});
Shucai Xiao's avatar
Shucai Xiao committed
1312
    auto l_ind_axis_indices =
Shucai Xiao's avatar
Shucai Xiao committed
1313
1314
        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
1315

1316
1317
    auto rsp_data    = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {12}}}), data);
    auto lbst_stride = mm->add_instruction(
1318
        migraphx::make_op("multibroadcast", {{"out_lens", ind_s.lens()}}), l_stride);
1319
1320
1321
1322
    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
1323
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
1324
1325
1326
1327
1328
1329

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1330
TEST_CASE(gemm_test)
1331
1332
{
    migraphx::program p;
1333
1334
1335
1336
    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});
Khalique's avatar
Khalique committed
1337
1338
    auto alpha = 2.f;
    auto beta  = 2.0f;
1339
1340
    auto a_l   = mm->add_literal(alpha);
    auto t_a   = add_common_op(*mm, migraphx::make_op("mul"), {a_l, l0});
1341
1342
1343
1344
1345
    t_a     = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), t_a);
    auto t1 = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), l1);

    auto dot =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), t_a, t1);
1346
1347
    auto b_l = mm->add_literal(beta);
    auto l2_b =
1348
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {7, 11}}}), l2);
1349
    auto b_b = mm->add_instruction(
1350
        migraphx::make_op("multibroadcast", {{"out_lens", l2_b->get_shape().lens()}}), b_l);
1351
    auto l2_bb = mm->add_instruction(migraphx::make_op("mul"), l2_b, b_b);
turneram's avatar
turneram committed
1352
1353
    mm->add_instruction(migraphx::make_op("add"), dot, l2_bb);

Shucai Xiao's avatar
Shucai Xiao committed
1354
    auto prog = optimize_onnx("gemm_test.onnx");
1355
1356
1357
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1358
TEST_CASE(gemm_ex_test)
1359
1360
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1361
1362
1363
1364
    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}});
Khalique's avatar
Khalique committed
1365
1366
    auto alpha = 0.5f;
    auto beta  = 0.8f;
1367
1368
    auto a_l   = mm->add_literal(alpha);
    auto t_a   = add_common_op(*mm, migraphx::make_op("mul"), {a_l, l0});
1369
    t_a = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), t_a);
1370
1371
1372

    auto dot =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), t_a, l1);
1373
1374
    auto b_l = mm->add_literal(beta);
    auto b_b = mm->add_instruction(
1375
        migraphx::make_op("multibroadcast", {{"out_lens", l2->get_shape().lens()}}), b_l);
1376
    auto l2_b = mm->add_instruction(migraphx::make_op("mul"), l2, b_b);
turneram's avatar
turneram committed
1377
    mm->add_instruction(migraphx::make_op("add"), dot, l2_b);
1378

Shucai Xiao's avatar
Shucai Xiao committed
1379
    auto prog = optimize_onnx("gemm_ex_test.onnx");
1380
1381
1382
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1383
TEST_CASE(gemm_ex_brcst_test)
1384
1385
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1386
1387
1388
1389
    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}});
Khalique's avatar
Khalique committed
1390
1391
1392
    std::vector<std::size_t> out_lens{1, 1, 6, 7};
    auto alpha = 0.5f;
    auto beta  = 0.8f;
1393
1394
    auto a_l   = mm->add_literal(alpha);
    auto t_a   = add_common_op(*mm, migraphx::make_op("mul"), {a_l, l0});
1395
    t_a = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), t_a);
1396
1397
1398

    auto dot =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), t_a, l1);
1399
1400
    auto b_l = mm->add_literal(beta);
    auto l2_b =
1401
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", out_lens}}), l2);
1402
    auto b_b = mm->add_instruction(
1403
        migraphx::make_op("multibroadcast", {{"out_lens", l2_b->get_shape().lens()}}), b_l);
1404
    auto l2_bb = mm->add_instruction(migraphx::make_op("mul"), l2_b, b_b);
turneram's avatar
turneram committed
1405
    mm->add_instruction(migraphx::make_op("add"), dot, l2_bb);
1406

Shucai Xiao's avatar
Shucai Xiao committed
1407
    auto prog = optimize_onnx("gemm_ex_brcst_test.onnx");
1408
1409
1410
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
TEST_CASE(gemm_half_test)
{
    migraphx::program p;
    auto* mm   = p.get_main_module();
    auto l0    = mm->add_parameter("1", migraphx::shape{migraphx::shape::half_type, {1, 1, 8, 6}});
    auto l1    = mm->add_parameter("2", migraphx::shape{migraphx::shape::half_type, {1, 1, 8, 7}});
    auto l2    = mm->add_parameter("3", migraphx::shape{migraphx::shape::half_type, {1, 1, 6, 1}});
    auto alpha = 0.5f;
    auto beta  = 0.8f;
    auto a_l   = mm->add_literal(alpha);
    auto t_a   = add_common_op(*mm, migraphx::make_op("mul"), {a_l, l0});
    t_a        = mm->add_instruction(
        migraphx::make_op("convert", {{"target_type", migraphx::shape::half_type}}), t_a);
1424
    t_a = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), t_a);
Shucai Xiao's avatar
Shucai Xiao committed
1425
    std::vector<std::size_t> lens = {1, 1, 6, 7};
1426
1427
    auto dot =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), t_a, l1);
1428
    l2 = mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", lens}}), l2);
Shucai Xiao's avatar
Shucai Xiao committed
1429
1430
    l2 = mm->add_instruction(
        migraphx::make_op("convert", {{"target_type", migraphx::shape::float_type}}), l2);
1431
1432
    auto b_l  = mm->add_literal(beta);
    auto b_b  = mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", lens}}), b_l);
Shucai Xiao's avatar
Shucai Xiao committed
1433
1434
1435
    auto l2_b = mm->add_instruction(migraphx::make_op("mul"), l2, b_b);
    l2_b      = mm->add_instruction(
        migraphx::make_op("convert", {{"target_type", migraphx::shape::half_type}}), l2_b);
turneram's avatar
turneram committed
1436
    mm->add_instruction(migraphx::make_op("add"), dot, l2_b);
Shucai Xiao's avatar
Shucai Xiao committed
1437
1438
1439
1440
1441

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

Khalique's avatar
Khalique committed
1442
TEST_CASE(globalavgpool_test)
1443
1444
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1445
1446
1447
    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
1448
1449
1450
    auto op    = migraphx::op::pooling{"average"};
    auto lens  = input->get_shape().lens();
    op.lengths = {lens[2], lens[3]};
kahmed10's avatar
kahmed10 committed
1451
    op.padding = {0, 0, 0, 0};
Shucai Xiao's avatar
Shucai Xiao committed
1452
    mm->add_instruction(op, input);
Khalique's avatar
Khalique committed
1453

Shucai Xiao's avatar
Shucai Xiao committed
1454
    auto prog = optimize_onnx("globalavgpool_test.onnx");
1455
1456
1457
1458

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1459
TEST_CASE(globalmaxpool_test)
Khalique's avatar
Khalique committed
1460
1461
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1462
1463
1464
    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
1465
1466
1467
    auto op    = migraphx::op::pooling{"max"};
    auto lens  = input->get_shape().lens();
    op.lengths = {lens[2], lens[3]};
kahmed10's avatar
kahmed10 committed
1468
    op.padding = {0, 0, 0, 0};
Shucai Xiao's avatar
Shucai Xiao committed
1469
    mm->add_instruction(op, input);
Khalique's avatar
Khalique committed
1470

Shucai Xiao's avatar
Shucai Xiao committed
1471
    auto prog = optimize_onnx("globalmaxpool_test.onnx");
Khalique's avatar
Khalique committed
1472
1473
1474
1475

    EXPECT(p == prog);
}

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

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

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

Khalique's avatar
Khalique committed
1516
TEST_CASE(group_conv_test)
1517
1518
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1519
1520
1521
    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
1522
1523
    migraphx::op::convolution op;
    op.group = 4;
Shucai Xiao's avatar
Shucai Xiao committed
1524
    mm->add_instruction(op, l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
1525
    auto prog = optimize_onnx("group_conv_test.onnx");
1526
1527
1528
1529

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1530
1531
1532
1533
1534
TEST_CASE(if_else_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape sc{migraphx::shape::bool_type, {1}};
Shucai Xiao's avatar
Shucai Xiao committed
1535
    auto cond = mm->add_literal(migraphx::literal(sc, {0}));
Shucai Xiao's avatar
Shucai Xiao committed
1536
1537
    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
    std::vector<float> ones(s.elements(), 1.0f);
Shucai Xiao's avatar
Shucai Xiao committed
1538
    auto l1                 = mm->add_literal(s, ones);
Shucai Xiao's avatar
Shucai Xiao committed
1539
1540
    std::vector<float> rand = {-0.583375, 0.633757, 0.0668345, -0.479422, -0.604634, 0.0388589};
    auto l2                 = mm->add_literal(s, rand);
Shucai Xiao's avatar
Shucai Xiao committed
1541
1542
1543
1544
1545
1546
    auto x                  = mm->add_parameter("x", s);
    auto y                  = mm->add_parameter("y", s);

    auto* then_mod = p.create_module("If_5_if");
    auto rt        = then_mod->add_instruction(migraphx::make_op("add"), x, l1);
    then_mod->add_return({rt});
Shucai Xiao's avatar
Shucai Xiao committed
1547

Shucai Xiao's avatar
Shucai Xiao committed
1548
1549
1550
    auto* else_mod = p.create_module("If_5_else");
    auto re        = else_mod->add_instruction(migraphx::make_op("mul"), y, l2);
    else_mod->add_return({re});
Shucai Xiao's avatar
Shucai Xiao committed
1551

Shucai Xiao's avatar
Shucai Xiao committed
1552
1553
    auto ret = mm->add_instruction(migraphx::make_op("if"), {cond}, {then_mod, else_mod});
    auto r   = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), ret);
Shucai Xiao's avatar
Shucai Xiao committed
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
    mm->add_return({r});

    std::ifstream ifs("if_else_test.onnx", std::ios::binary);
    ifs.seekg(0, std::ios::end);
    auto length = ifs.tellg();
    ifs.seekg(0, std::ios::beg);
    std::vector<char> onnx_buffer(length);
    ifs.read(onnx_buffer.data(), length);
    ifs.close();

    auto prog = migraphx::parse_onnx_buffer(onnx_buffer.data(), length, {});
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
TEST_CASE(if_literal_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape cond_s{migraphx::shape::bool_type};
    auto cond = mm->add_parameter("cond", cond_s);

    migraphx::shape s{migraphx::shape::float_type, {5}};

    auto* then_mod           = p.create_module("If_1_if");
    std::vector<float> data1 = {1, 2, 3, 4, 5};
    auto l1                  = then_mod->add_literal(migraphx::literal(s, data1));
Shucai Xiao's avatar
Shucai Xiao committed
1580
    then_mod->add_literal({});
Shucai Xiao's avatar
Shucai Xiao committed
1581
1582
1583
1584
1585
    then_mod->add_return({l1});

    auto* else_mod           = p.create_module("If_1_else");
    std::vector<float> data2 = {5, 4, 3, 2, 1};
    auto l2                  = else_mod->add_literal(migraphx::literal(s, data2));
Shucai Xiao's avatar
Shucai Xiao committed
1586
    else_mod->add_literal({});
Shucai Xiao's avatar
Shucai Xiao committed
1587
1588
1589
    else_mod->add_return({l2});

    auto ret = mm->add_instruction(migraphx::make_op("if"), {cond}, {then_mod, else_mod});
Shucai Xiao's avatar
Shucai Xiao committed
1590
1591
    auto r   = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), ret);
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
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

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

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

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

TEST_CASE(if_param_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape cond_s{migraphx::shape::bool_type};
    auto cond = mm->add_parameter("cond", cond_s);
    migraphx::shape ds{migraphx::shape::float_type, {2, 3}};
    auto x = mm->add_parameter("x", ds);
    auto y = mm->add_parameter("y", ds);

    auto* then_mod           = p.create_module("If_3_if");
    std::vector<float> data1 = {0.384804, -1.77948, -0.453775, 0.477438, -1.06333, -1.12893};
    auto l1                  = then_mod->add_literal(migraphx::literal(ds, data1));
    auto a1                  = then_mod->add_instruction(migraphx::make_op("add"), x, l1);
    then_mod->add_return({a1});

    auto* else_mod           = p.create_module("If_3_else");
    std::vector<float> data2 = {-0.258047, 0.360394, 0.536804, -0.577762, 1.0217, 1.02442};
    auto l2                  = else_mod->add_literal(migraphx::literal(ds, data2));
    auto a2                  = else_mod->add_instruction(migraphx::make_op("mul"), y, l2);
    else_mod->add_return({a2});

    auto ret = mm->add_instruction(migraphx::make_op("if"), {cond}, {then_mod, else_mod});
Shucai Xiao's avatar
Shucai Xiao committed
1630
1631
    auto r   = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), ret);
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663

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

TEST_CASE(if_pl_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape cond_s{migraphx::shape::bool_type};
    migraphx::shape xs{migraphx::shape::float_type, {2, 3}};
    migraphx::shape ys{migraphx::shape::float_type, {3, 3}};
    std::vector<float> datax = {1, 2, 3, 4, 5, 6};
    std::vector<float> datay = {8, 7, 6, 5, 4, 3, 2, 1, 0};

    auto lx   = mm->add_literal(migraphx::literal(xs, datax));
    auto ly   = mm->add_literal(migraphx::literal(ys, datay));
    auto cond = mm->add_parameter("cond", cond_s);
    auto x    = mm->add_parameter("x", xs);
    auto y    = mm->add_parameter("y", ys);

    auto* then_mod = p.create_module("If_5_if");
    auto l1        = then_mod->add_literal(migraphx::literal(ys, datay));
    auto a1        = then_mod->add_instruction(migraphx::make_op("add"), x, lx);
    then_mod->add_return({a1, l1});

    auto* else_mod = p.create_module("If_5_else");
    auto l2        = else_mod->add_literal(migraphx::literal(xs, datax));
    auto a2        = else_mod->add_instruction(migraphx::make_op("mul"), y, ly);
    else_mod->add_return({l2, a2});

    auto ret = mm->add_instruction(migraphx::make_op("if"), {cond}, {then_mod, else_mod});
Shucai Xiao's avatar
Shucai Xiao committed
1664
1665
1666
    auto r   = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), ret);
    mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), ret);
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
1667
1668
1669
1670
1671

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

Shucai Xiao's avatar
Shucai Xiao committed
1672
1673
1674
1675
1676
TEST_CASE(if_then_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape sc{migraphx::shape::bool_type, {1}};
Shucai Xiao's avatar
Shucai Xiao committed
1677
    auto cond = mm->add_literal(migraphx::literal(sc, {1}));
Shucai Xiao's avatar
Shucai Xiao committed
1678
1679
1680
1681
    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
    std::vector<float> ones(s.elements(), 1.0f);
    auto l1                 = mm->add_literal(s, ones);
    std::vector<float> rand = {-1.26487, -2.42279, 0.990835, 1.63072, 0.812238, -0.174946};
Shucai Xiao's avatar
Shucai Xiao committed
1682
1683
1684
    auto l2                 = mm->add_literal(s, rand);
    auto x                  = mm->add_parameter("x", s);
    auto y                  = mm->add_parameter("y", s);
Shucai Xiao's avatar
Shucai Xiao committed
1685

Shucai Xiao's avatar
Shucai Xiao committed
1686
1687
1688
1689
1690
1691
1692
    auto* then_mod = p.create_module("If_5_if");
    auto rt        = then_mod->add_instruction(migraphx::make_op("add"), x, l1);
    then_mod->add_return({rt});

    auto* else_mod = p.create_module("If_5_else");
    auto re        = else_mod->add_instruction(migraphx::make_op("mul"), y, l2);
    else_mod->add_return({re});
Shucai Xiao's avatar
Shucai Xiao committed
1693

Shucai Xiao's avatar
Shucai Xiao committed
1694
1695
    auto ret = mm->add_instruction(migraphx::make_op("if"), {cond}, {then_mod, else_mod});
    auto r   = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), ret);
Shucai Xiao's avatar
Shucai Xiao committed
1696
1697
1698
    mm->add_return({r});

    auto prog = migraphx::parse_onnx("if_then_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
    EXPECT(p == prog);
}

TEST_CASE(if_tuple_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape sd{migraphx::shape::float_type, {1}};
    auto l1 = mm->add_literal(migraphx::literal(sd, {1}));
    auto l2 = mm->add_literal(migraphx::literal(sd, {2}));
    auto l3 = mm->add_literal(migraphx::literal(sd, {3}));
    migraphx::shape sx{migraphx::shape::float_type, {1, 4}};
    migraphx::shape sy{migraphx::shape::float_type, {3, 4}};
    migraphx::shape sc{migraphx::shape::bool_type};
    auto cond = mm->add_parameter("cond", sc);
    auto x    = mm->add_parameter("x", sx);
    auto y    = mm->add_parameter("y", sy);

    auto* then_mod = p.create_module("If_6_if");
1718
1719
    auto m1 =
        then_mod->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {1, 4}}}), l1);
Shucai Xiao's avatar
Shucai Xiao committed
1720
    auto add0 = then_mod->add_instruction(migraphx::make_op("add"), x, m1);
1721
1722
    auto m2 =
        then_mod->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3, 4}}}), l2);
Shucai Xiao's avatar
Shucai Xiao committed
1723
1724
1725
1726
    auto mul0 = then_mod->add_instruction(migraphx::make_op("mul"), y, m2);
    then_mod->add_return({add0, mul0});

    auto* else_mod = p.create_module("If_6_else");
1727
1728
    auto me1 =
        else_mod->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {1, 4}}}), l3);
Shucai Xiao's avatar
Shucai Xiao committed
1729
    auto mul1 = else_mod->add_instruction(migraphx::make_op("mul"), x, me1);
1730
1731
    auto me2 =
        else_mod->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3, 4}}}), l3);
Shucai Xiao's avatar
Shucai Xiao committed
1732
1733
1734
1735
1736
1737
1738
    auto add1 = else_mod->add_instruction(migraphx::make_op("add"), y, me2);
    else_mod->add_return({mul1, add1});

    auto ret = mm->add_instruction(migraphx::make_op("if"), {cond}, {then_mod, else_mod});
    auto r0  = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), ret);
    auto r1  = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), ret);
    mm->add_return({r0, r1});
Shucai Xiao's avatar
Shucai Xiao committed
1739

Shucai Xiao's avatar
Shucai Xiao committed
1740
    auto prog = migraphx::parse_onnx("if_tuple_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
1741
1742
1743
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1744
TEST_CASE(imagescaler_test)
1745
1746
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1747
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
1748
    migraphx::shape s{migraphx::shape::float_type, {1, 3, 16, 16}};
Shucai Xiao's avatar
Shucai Xiao committed
1749
1750
1751
    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
1752
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
1753
1754
1755
1756
    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(
1757
        migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", s.lens()}}), bias_vals);
1758
    mm->add_instruction(migraphx::make_op("add"), img_scaled, bias_bcast);
Khalique's avatar
Khalique committed
1759

Shucai Xiao's avatar
Shucai Xiao committed
1760
    auto prog = optimize_onnx("imagescaler_test.onnx");
1761
1762
1763
1764

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1765
1766
1767
TEST_CASE(imagescaler_half_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1768
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1769
    migraphx::shape s{migraphx::shape::half_type, {1, 3, 16, 16}};
Shucai Xiao's avatar
Shucai Xiao committed
1770
    auto l0 = mm->add_parameter("0", s);
Shucai Xiao's avatar
Shucai Xiao committed
1771
    auto scale_val =
Shucai Xiao's avatar
Shucai Xiao committed
1772
1773
        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
1774
        migraphx::literal{migraphx::shape{migraphx::shape::half_type, {3}}, {0.01, 0.02, 0.03}});
1775
1776
1777
1778
    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(
1779
        migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", s.lens()}}), bias_vals);
1780
    mm->add_instruction(migraphx::make_op("add"), img_scaled, bias_bcast);
Shucai Xiao's avatar
Shucai Xiao committed
1781
1782
1783
1784
1785
1786

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1787
TEST_CASE(implicit_add_bcast_test)
1788
1789
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1790
1791
1792
    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}});
1793
1794
    auto l3 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 4, 5}}}), l1);
1795
    mm->add_instruction(migraphx::make_op("add"), l0, l3);
Khalique's avatar
Khalique committed
1796

Shucai Xiao's avatar
Shucai Xiao committed
1797
    auto prog = optimize_onnx("implicit_add_bcast_test.onnx");
1798
1799
1800
1801

    EXPECT(p == prog);
}

1802
1803
1804
TEST_CASE(implicit_add_bcast_user_input_shape_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1805
1806
1807
    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}});
1808
1809
    auto l3 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3, 4, 5, 6}}}), l1);
1810
    auto r = mm->add_instruction(migraphx::make_op("add"), l0, l3);
Shucai Xiao's avatar
Shucai Xiao committed
1811
    mm->add_return({r});
1812
1813
1814
1815
1816
1817
1818
1819
1820

    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
1821
TEST_CASE(implicit_pow_bcast_test)
1822
1823
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1824
1825
1826
    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}});
1827
1828
    auto l3 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 4, 5}}}), l1);
1829
    mm->add_instruction(migraphx::make_op("pow"), l0, l3);
Khalique's avatar
Khalique committed
1830

Shucai Xiao's avatar
Shucai Xiao committed
1831
    auto prog = optimize_onnx("implicit_pow_bcast_test.onnx");
1832
1833
1834
1835

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1836
TEST_CASE(implicit_sub_bcast_test)
1837
1838
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1839
1840
1841
    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}});
1842
1843
    auto l3 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 4, 5}}}), l1);
1844
    mm->add_instruction(migraphx::make_op("sub"), l0, l3);
Khalique's avatar
Khalique committed
1845

Shucai Xiao's avatar
Shucai Xiao committed
1846
    auto prog = optimize_onnx("implicit_sub_bcast_test.onnx");
1847
1848
1849
1850

    EXPECT(p == prog);
}

1851
1852
1853
TEST_CASE(initializer_not_an_input)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1854
    auto* mm             = p.get_main_module();
1855
    std::vector<float> w = {1, 2, 3, 4, 5, 6, 7, 8};
Shucai Xiao's avatar
Shucai Xiao committed
1856
1857
    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}});
1858
1859
    mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), l0, l1);

Shucai Xiao's avatar
Shucai Xiao committed
1860
    auto prog = optimize_onnx("initializer_not_an_input.onnx");
kahmed10's avatar
kahmed10 committed
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871

    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
1872
1873
1874
1875
1876
    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);

1877
1878
    auto mean = mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2, 3}}}), x);
    auto mean_bcast =
1879
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", dims}}), mean);
1880
1881
1882
    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
1883
    auto epsilon_literal = mm->add_literal(1e-5f);
1884
    auto epsilon_bcast   = mm->add_instruction(
1885
        migraphx::make_op("multibroadcast", {{"out_lens", dims}}), epsilon_literal);
1886
    auto variance_bcast =
1887
1888
1889
1890
1891
1892
1893
1894
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_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}, {"out_lens", dims}}), scale);
    auto bias_bcast = mm->add_instruction(
        migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", dims}}), bias);
1895
1896
    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
1897
1898

    auto prog = optimize_onnx("instance_norm_test.onnx");
1899
1900
1901
1902

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
1903
TEST_CASE(leaky_relu_test)
1904
1905
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1906
    auto* mm    = p.get_main_module();
Khalique's avatar
Khalique committed
1907
    float alpha = 0.01f;
Shucai Xiao's avatar
Shucai Xiao committed
1908
    auto l0     = mm->add_parameter("0", {migraphx::shape::float_type, {3}});
1909
    mm->add_instruction(migraphx::make_op("leaky_relu", {{"alpha", alpha}}), l0);
Khalique's avatar
Khalique committed
1910

Shucai Xiao's avatar
Shucai Xiao committed
1911
    auto prog = optimize_onnx("leaky_relu_test.onnx");
1912
1913
1914
1915

    EXPECT(p == prog);
}

1916
1917
1918
TEST_CASE(less_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1919
    auto* mm = p.get_main_module();
1920
1921
1922
    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
1923
1924
    auto input1 = mm->add_literal(migraphx::literal(s, data));
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
1925
1926
1927
1928
1929
    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
1930
    mm->add_return({ret});
1931
1932
1933
1934
1935
1936
1937
1938

    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
1939
    auto* mm = p.get_main_module();
1940
1941
1942
    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
1943
1944
    auto input1 = mm->add_parameter("x1", sf);
    auto input2 = mm->add_parameter("x2", sb);
1945
1946
1947
1948
1949
    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
1950
    mm->add_return({ret});
1951
1952
1953
1954
1955

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

Cagri Eryilmaz's avatar
Cagri Eryilmaz committed
1956
1957
1958
1959
1960
1961
1962
TEST_CASE(lessorequal_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();

    auto input1 = mm->add_parameter("x1", migraphx::shape{migraphx::shape::float_type, {3}});
    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {3}});
kahmed10's avatar
kahmed10 committed
1963
    auto temp   = mm->add_instruction(migraphx::make_op("greater"), input1, input2);
Shucai Xiao's avatar
Shucai Xiao committed
1964
1965
1966
    auto bt     = mm->add_instruction(
        migraphx::make_op("convert", {{"target_type", migraphx::shape::bool_type}}), temp);
    auto le = mm->add_instruction(migraphx::make_op("not"), bt);
kahmed10's avatar
kahmed10 committed
1967

Cagri Eryilmaz's avatar
Cagri Eryilmaz committed
1968
1969
1970
1971
1972
1973
    mm->add_return({le});

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

Khalique's avatar
Khalique committed
1974
TEST_CASE(log_test)
1975
1976
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
1977
1978
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
1979
    mm->add_instruction(migraphx::make_op("log"), input);
1980

Shucai Xiao's avatar
Shucai Xiao committed
1981
    auto prog = optimize_onnx("log_test.onnx");
1982
1983
1984
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
1985
1986
1987
1988
1989
1990
1991
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(
1992
        migraphx::make_op("multibroadcast", {{"out_lens", l0->get_shape().lens()}}), l1);
Shucai Xiao's avatar
Shucai Xiao committed
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
    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(
2022
        migraphx::make_op("multibroadcast", {{"out_lens", l0->get_shape().lens()}}), l1);
Shucai Xiao's avatar
Shucai Xiao committed
2023
2024
2025
2026
2027
2028
2029
2030
    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
2031
TEST_CASE(logsoftmax_test)
2032
2033
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2034
2035
    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
2036
    int axis = 1;
2037
    mm->add_instruction(migraphx::make_op("logsoftmax", {{"axis", axis}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2038
    auto prog = optimize_onnx("logsoftmax_test.onnx");
2039
2040
2041
2042

    EXPECT(p == prog);
}

2043
2044
2045
2046
2047
2048
2049
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);
Shucai Xiao's avatar
Shucai Xiao committed
2050
    auto l2 = mm->add_instruction(migraphx::make_op("logsoftmax", {{"axis", -1}}), l1);
2051
2052
2053
2054
2055
2056
2057
    mm->add_return({l2});

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
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
TEST_CASE(loop_default_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();

    migraphx::shape su{migraphx::shape::float_type};
    auto a = mm->add_parameter("a", su);
    auto b = mm->add_parameter("b", su);
    migraphx::shape si{migraphx::shape::int64_type};
    auto max_iter = mm->add_literal(migraphx::literal(si, {10}));
    migraphx::shape sc{migraphx::shape::bool_type};
    auto icond = mm->add_literal(migraphx::literal(sc, {1}));
    mm->add_instruction(migraphx::make_op("undefined"));

    auto* body = p.create_module("Loop_3_loop");
    body->add_parameter("iteration_num", {migraphx::shape::int64_type});
    body->add_parameter("keep_going_inp", {migraphx::shape::bool_type});
    auto var = body->add_parameter("b_in", su);

    auto ad = body->add_instruction(migraphx::make_op("add"), a, var);
    auto sb = body->add_instruction(migraphx::make_op("sub"), a, var);
    auto gt = body->add_instruction(migraphx::make_op("greater"), ad, sb);
    auto cv = body->add_instruction(
        migraphx::make_op("convert", {{"target_type", migraphx::shape::bool_type}}), gt);
    auto ad1 = body->add_instruction(migraphx::make_op("add"), sb, sb);
    body->add_return({cv, sb, ad, ad1});

    auto lp = mm->add_instruction(
        migraphx::make_op("loop", {{"max_iterations", 10}}), {max_iter, icond, b}, {body});
    auto r0 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), lp);
    mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), lp);
    auto r2 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 2}}), lp);
    mm->add_return({r0, r2});

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

    EXPECT(p == prog);
}

TEST_CASE(loop_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape si{migraphx::shape::int64_type, {1}};
    auto max_iter = mm->add_parameter("max_trip_count", si);
    migraphx::shape sc{migraphx::shape::bool_type, {1}};
    auto icond = mm->add_parameter("keep_going_cond", sc);
    migraphx::shape su{migraphx::shape::float_type, {1}};
    auto a = mm->add_parameter("a", su);
    auto b = mm->add_parameter("b", su);

    auto* body = p.create_module("Loop_4_loop");
    body->add_parameter("iteration_num", si);
    body->add_parameter("keep_going_inp", sc);
    auto var = body->add_parameter("b_in", su);

    auto ad = body->add_instruction(migraphx::make_op("add"), a, var);
    auto sb = body->add_instruction(migraphx::make_op("sub"), a, var);
    auto gt = body->add_instruction(migraphx::make_op("greater"), ad, sb);
    auto cv = body->add_instruction(
        migraphx::make_op("convert", {{"target_type", migraphx::shape::bool_type}}), gt);
    auto ad1 = body->add_instruction(migraphx::make_op("add"), sb, sb);
    body->add_return({cv, sb, ad, ad1});

    auto lp = mm->add_instruction(
        migraphx::make_op("loop", {{"max_iterations", 10}}), {max_iter, icond, b}, {body});
    auto r0 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), lp);
    mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), lp);
    auto r2 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 2}}), lp);
    mm->add_return({r0, r2});

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2134
TEST_CASE(lrn_test)
2135
2136
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2137
2138
    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
2139
2140
2141
2142
2143
    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
2144
    mm->add_instruction(op, l0);
Shucai Xiao's avatar
Shucai Xiao committed
2145
    auto prog = optimize_onnx("lrn_test.onnx");
2146
2147
2148
2149

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2150
TEST_CASE(matmul_bmbm_test)
2151
2152
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2153
2154
2155
    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}});
2156
    auto bl0 = mm->add_instruction(
2157
        migraphx::make_op("multibroadcast", {{"out_lens", {5, 2, 3, 6, 7}}}), l0);
2158
    auto bl1 = mm->add_instruction(
2159
        migraphx::make_op("multibroadcast", {{"out_lens", {5, 2, 3, 7, 8}}}), l1);
2160
2161
    mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), bl0, bl1);

Shucai Xiao's avatar
Shucai Xiao committed
2162
    auto prog = optimize_onnx("matmul_bmbm_test.onnx");
2163
2164
2165
2166

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2167
TEST_CASE(matmul_bmv_test)
2168
{
Khalique's avatar
Khalique committed
2169
    migraphx::program p;
2170
2171
2172
2173
2174
    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 =
2175
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3, 7, 1}}}), sl1);
2176
2177
    auto res =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), l0, bsl1);
2178
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {2}}}), res);
2179

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

Khalique's avatar
Khalique committed
2182
    EXPECT(p == prog);
2183
2184
}

Khalique's avatar
Khalique committed
2185
TEST_CASE(matmul_mv_test)
2186
2187
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2188
2189
2190
    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}});
2191
    auto sl1 = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1}}}), l1);
2192
2193
    auto res =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), l0, sl1);
2194
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {1}}}), res);
Khalique's avatar
Khalique committed
2195

Shucai Xiao's avatar
Shucai Xiao committed
2196
    auto prog = optimize_onnx("matmul_mv_test.onnx");
2197
2198
2199
2200

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2201
TEST_CASE(matmul_vbm_test)
2202
2203
{
    migraphx::program p;
2204
2205
2206
2207
2208
    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 =
2209
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {5, 1, 7}}}), sl0);
2210
2211
    auto res =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), bsl0, l1);
2212
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {1}}}), res);
Khalique's avatar
Khalique committed
2213

Shucai Xiao's avatar
Shucai Xiao committed
2214
    auto prog = optimize_onnx("matmul_vbm_test.onnx");
2215
2216
2217
2218

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2219
TEST_CASE(matmul_vm_test)
2220
2221
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2222
2223
2224
    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}});
2225
    auto sl0 = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {0}}}), l0);
2226
2227
    auto res =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), sl0, l1);
2228
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {0}}}), res);
Khalique's avatar
Khalique committed
2229

Shucai Xiao's avatar
Shucai Xiao committed
2230
    auto prog = optimize_onnx("matmul_vm_test.onnx");
2231
2232
2233
2234

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2235
TEST_CASE(matmul_vv_test)
2236
2237
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2238
2239
2240
    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}});
2241
2242
    auto sl0 = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {0}}}), l0);
    auto sl1 = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1}}}), l1);
2243
2244
    auto res =
        mm->add_instruction(migraphx::make_op("dot", {{"alpha", 1.0f}, {"beta", 0.0f}}), sl0, sl1);
2245
2246
    auto sr0 = mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {0}}}), res);
    mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {0}}}), sr0);
2247

Shucai Xiao's avatar
Shucai Xiao committed
2248
    auto prog = optimize_onnx("matmul_vv_test.onnx");
2249
2250
2251
2252

    EXPECT(p == prog);
}

2253
2254
2255
TEST_CASE(matmulinteger_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2256
2257
2258
    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}});
2259
    mm->add_instruction(migraphx::make_op("quant_dot", {{"alpha", 1}, {"beta", 0}}), l0, l1);
2260
2261
2262
2263
2264
2265

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2266
TEST_CASE(max_test)
2267
2268
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2269
2270
2271
2272
    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}});
2273
2274
    auto l0     = mm->add_instruction(migraphx::make_op("max"), input0, input1);
    mm->add_instruction(migraphx::make_op("max"), l0, input2);
2275

Shucai Xiao's avatar
Shucai Xiao committed
2276
    optimize_onnx("max_test.onnx");
Khalique's avatar
Khalique committed
2277
}
2278

2279
2280
2281
TEST_CASE(maxpool_notset_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2282
2283
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
2284
2285
2286
    mm->add_instruction(
        migraphx::make_op(
            "pooling",
kahmed10's avatar
kahmed10 committed
2287
2288
            {{"mode", "max"}, {"padding", {0, 0, 1, 1}}, {"stride", {2, 2}}, {"lengths", {6, 6}}}),
        input);
2289
2290
2291
2292
2293
2294
2295
2296
2297

    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
2298
2299
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
2300
2301
2302
    mm->add_instruction(
        migraphx::make_op(
            "pooling",
kahmed10's avatar
kahmed10 committed
2303
2304
            {{"mode", "max"}, {"padding", {0, 0, 1, 1}}, {"stride", {1, 1}}, {"lengths", {2, 2}}}),
        input);
2305
2306
2307
2308
2309
2310

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2311
2312
2313
TEST_CASE(min_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2314
2315
2316
2317
    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}});
2318
2319
    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
2320

Shucai Xiao's avatar
Shucai Xiao committed
2321
    optimize_onnx("min_test.onnx");
2322
2323
}

Khalique's avatar
Khalique committed
2324
TEST_CASE(no_pad_test)
2325
2326
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2327
2328
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
2329
    mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2330
    auto prog = optimize_onnx("no_pad_test.onnx");
2331

Khalique's avatar
Khalique committed
2332
2333
2334
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2335
2336
2337
TEST_CASE(neg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2338
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2339
    migraphx::shape s{migraphx::shape::int64_type, {2, 3}};
Shucai Xiao's avatar
Shucai Xiao committed
2340
    auto input = mm->add_parameter("0", s);
2341
    auto ret   = mm->add_instruction(migraphx::make_op("neg"), input);
Shucai Xiao's avatar
Shucai Xiao committed
2342
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
2343
2344
2345
2346
2347
2348

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2349
2350
2351
TEST_CASE(nonzero_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2352
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2353
2354
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
    std::vector<float> data = {1, 0, 1, 1};
Shucai Xiao's avatar
Shucai Xiao committed
2355
    mm->add_literal(migraphx::literal(s, data));
Shucai Xiao's avatar
Shucai Xiao committed
2356
2357
2358

    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
2359
2360
    auto r                       = mm->add_literal(migraphx::literal(si, indices));
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2361
2362
2363
2364
2365
2366
2367
2368

    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
2369
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2370
    migraphx::shape s{migraphx::shape::int16_type, {2, 3}};
Shucai Xiao's avatar
Shucai Xiao committed
2371
    std::vector<int> data = {1, 1, 0, 1, 0, 1};
Shucai Xiao's avatar
Shucai Xiao committed
2372
    mm->add_literal(migraphx::literal(s, data.begin(), data.end()));
Shucai Xiao's avatar
Shucai Xiao committed
2373
2374
2375

    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
2376
2377
    auto r                       = mm->add_literal(migraphx::literal(si, indices));
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2378
2379
2380
2381
2382

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

2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
TEST_CASE(not_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::int32_type, {4}});
    auto ret = mm->add_instruction(migraphx::make_op("not"), l0);
    mm->add_return({ret});

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

    EXPECT(p == prog);
}

TEST_CASE(not_bool_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::bool_type, {4}});
    auto ret = mm->add_instruction(migraphx::make_op("not"), l0);
    mm->add_return({ret});

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
2409
2410
2411
TEST_CASE(onehot_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2412
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2413
2414
    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
2415
2416
2417
    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
2418
2419
    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
2420
    auto l_dep      = mm->add_literal(migraphx::literal(s_dep, data_dep));
2421
    auto gather_out = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), l_dep, l_ind);
2422
2423
    auto tr_out  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {2, 0, 1}}}),
                                      gather_out);
2424
2425
2426
2427
2428
2429
    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(
2430
2431
2432
        migraphx::make_op("multibroadcast", {{"out_lens", {3, 5, 2}}}), off_val);
    auto mb_diff =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3, 5, 2}}}), diff);
2433
2434
    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
2435
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
2436
2437

    auto prog = migraphx::parse_onnx("onehot_test.onnx");
kahmed10's avatar
kahmed10 committed
2438
2439
2440
2441

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2442
2443
2444
TEST_CASE(pad_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2445
2446
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
2447
    mm->add_instruction(migraphx::make_op("pad", {{"pads", {1, 1, 1, 1}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2448
    auto prog = optimize_onnx("pad_test.onnx");
2449
2450
2451
2452

    EXPECT(p == prog);
}

2453
2454
2455
TEST_CASE(pad_3arg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2456
2457
2458
2459
    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}});
2460
2461
    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
2462
    mm->add_return({r});
2463
2464
2465
2466
2467
2468

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
2469
2470
2471
TEST_CASE(pad_reflect_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2472
2473
2474
    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}});
2475
2476
2477
2478
2479
2480
2481
    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
2482
    mm->add_return({r});
kahmed10's avatar
kahmed10 committed
2483
2484
2485
2486
2487
2488
2489
2490
2491

    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
2492
2493
2494
    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}});
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
    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
2505
    mm->add_return({r});
kahmed10's avatar
kahmed10 committed
2506
2507
2508
2509
2510
2511

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2512
TEST_CASE(pow_test)
2513
2514
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2515
2516
2517
    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}});
2518
    mm->add_instruction(migraphx::make_op("pow"), l0, l1);
2519

Shucai Xiao's avatar
Shucai Xiao committed
2520
    auto prog = optimize_onnx("pow_test.onnx");
2521
2522
2523
2524

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
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);
}

turneram's avatar
turneram committed
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
TEST_CASE(prefix_scan_sum)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    mm->add_literal({migraphx::shape{migraphx::shape::int32_type, {1}, {1}}, {0}});
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2, 2, 2}});
    auto ret = mm->add_instruction(
        migraphx::make_op("prefix_scan_sum", {{"axis", 0}, {"exclusive", true}, {"reverse", true}}),
        l0);
    mm->add_return({ret});

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

Shucai Xiao's avatar
Shucai Xiao committed
2574
2575
2576
TEST_CASE(prelu_brcst_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2577
2578
2579
    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}});
2580
    auto bl1 = mm->add_instruction(
2581
        migraphx::make_op("multibroadcast", {{"out_lens", l0->get_shape().lens()}}), l1);
2582
    auto ret = mm->add_instruction(migraphx::make_op("prelu"), l0, bl1);
Shucai Xiao's avatar
Shucai Xiao committed
2583
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
2584
2585
2586
2587
2588
2589

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

    EXPECT(p == prog);
}

2590
2591
2592
TEST_CASE(quantizelinear_test)
{
    migraphx::program p;
turneram's avatar
turneram committed
2593
2594
2595
    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}});
2596
    auto l1_mbcast =
2597
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {5}}}), l1);
turneram's avatar
turneram committed
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
    auto div   = mm->add_instruction(migraphx::make_op("div"), l0, l1_mbcast);
    auto round = mm->add_instruction(migraphx::make_op("round"), div);
    auto s     = round->get_shape();
    std::vector<int> min_data(s.elements(), 0);
    std::vector<int> max_data(s.elements(), 255);
    auto min_arg = mm->add_literal(s, min_data);
    auto max_arg = mm->add_literal(s, max_data);
    auto clip    = mm->add_instruction(migraphx::make_op("clip"), round, min_arg, max_arg);
    mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::uint8_type)}}),
        clip);
2610

turneram's avatar
turneram committed
2611
2612
2613
    auto prog = optimize_onnx("quantizelinear_test.onnx", true);
    EXPECT(p.sort() == prog.sort());
}
2614

turneram's avatar
turneram committed
2615
2616
2617
2618
2619
2620
2621
TEST_CASE(quantizelinear_int32_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", {migraphx::shape::int32_type, {5}});
    auto l1  = mm->add_parameter("1", {migraphx::shape::float_type, {1}});
    auto l1_mbcast =
2622
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {5}}}), l1);
turneram's avatar
turneram committed
2623
2624
2625
2626
    l0 = mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
        l0);
2627
2628
    auto div   = mm->add_instruction(migraphx::make_op("div"), l0, l1_mbcast);
    auto round = mm->add_instruction(migraphx::make_op("round"), div);
turneram's avatar
turneram committed
2629
2630
2631
2632
2633
2634
2635
    auto s     = round->get_shape();
    std::vector<int> min_data(s.elements(), 0);
    std::vector<int> max_data(s.elements(), 255);
    auto min_arg = mm->add_literal(s, min_data);
    auto max_arg = mm->add_literal(s, max_data);
    auto clip    = mm->add_instruction(migraphx::make_op("clip"), round, min_arg, max_arg);
    mm->add_instruction(
2636
        migraphx::make_op("convert",
turneram's avatar
turneram committed
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
                          {{"target_type", migraphx::to_value(migraphx::shape::uint8_type)}}),
        clip);

    auto prog = optimize_onnx("quantizelinear_int32_test.onnx", true);
    EXPECT(p.sort() == prog.sort());
}

TEST_CASE(quantizelinear_zero_point_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 l1_mbcast =
2652
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {5}}}), l1);
turneram's avatar
turneram committed
2653
2654
    auto div   = mm->add_instruction(migraphx::make_op("div"), l0, l1_mbcast);
    auto round = mm->add_instruction(migraphx::make_op("round"), div);
2655
    auto l2_mbcast =
2656
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {5}}}), l2);
turneram's avatar
turneram committed
2657
    l2_mbcast = mm->add_instruction(
2658
        migraphx::make_op("convert",
turneram's avatar
turneram committed
2659
2660
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
        l2_mbcast);
Shucai Xiao's avatar
Shucai Xiao committed
2661
    auto add = mm->add_instruction(migraphx::make_op("add"), round, l2_mbcast);
turneram's avatar
turneram committed
2662
2663
2664
2665
2666
2667
    auto s   = round->get_shape();
    std::vector<int> min_data(s.elements(), -128);
    std::vector<int> max_data(s.elements(), 127);
    auto min_arg = mm->add_literal(s, min_data);
    auto max_arg = mm->add_literal(s, max_data);
    auto clip    = mm->add_instruction(migraphx::make_op("clip"), add, min_arg, max_arg);
2668
2669
2670
2671
2672
    mm->add_instruction(
        migraphx::make_op("convert",
                          {{"target_type", migraphx::to_value(migraphx::shape::int8_type)}}),
        clip);

turneram's avatar
turneram committed
2673
    auto prog = optimize_onnx("quantizelinear_zero_point_test.onnx", true);
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
    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();

turneram's avatar
turneram committed
2684
2685
2686
    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}});
2687
    auto l1_bcast = mm->add_instruction(
2688
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", input_lens}}), l1);
2689
2690
2691
2692

    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(
2693
        migraphx::make_op("broadcast", {{"axis", axis}, {"out_lens", input_lens}}), l2);
2694
2695
    l2_bcast = mm->add_instruction(
        migraphx::make_op("convert",
turneram's avatar
turneram committed
2696
                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
2697
        l2_bcast);
Shucai Xiao's avatar
Shucai Xiao committed
2698
    auto add = mm->add_instruction(migraphx::make_op("add"), round, l2_bcast);
turneram's avatar
turneram committed
2699
2700
2701
2702
2703
2704
    auto s   = round->get_shape();
    std::vector<int> min_data(s.elements(), -128);
    std::vector<int> max_data(s.elements(), 127);
    auto min_arg = mm->add_literal(s, min_data);
    auto max_arg = mm->add_literal(s, max_data);
    auto clip    = mm->add_instruction(migraphx::make_op("clip"), add, min_arg, max_arg);
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
    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();

turneram's avatar
turneram committed
2716
    auto prog = optimize_onnx("quantizelinear_axis_test.onnx", true);
2717
2718
2719
2720
2721
2722
2723
    EXPECT(p.sort() == prog.sort());
}

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

turneram's avatar
turneram committed
2724
    auto prog = optimize_onnx("quantizelinear_neg_axis_test.onnx", true);
2725
2726
2727
    EXPECT(p.sort() == prog.sort());
}

kahmed10's avatar
kahmed10 committed
2728
2729
2730
TEST_CASE(range_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2731
2732
2733
2734
2735
    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
2736
2737
2738
2739
2740
2741
2742
2743
2744

    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
2745
2746
2747
2748
2749
    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
2750
2751
2752
2753
2754
2755

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
2756
2757
2758
TEST_CASE(recip_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2759
2760
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3}});
2761
    mm->add_instruction(migraphx::make_op("recip"), input);
kahmed10's avatar
kahmed10 committed
2762
2763
2764
2765
2766
2767

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2768
2769
2770
TEST_CASE(reducel1_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2771
2772
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2773
2774
2775
    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
2776
2777
2778
2779
2780
2781
2782
2783
    auto prog = optimize_onnx("reducel1_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(reducel2_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2784
2785
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2786
2787
2788
2789
    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
2790
2791
2792
2793
2794
2795
2796
2797
    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
2798
2799
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2800
2801
    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
2802
2803
2804
2805
2806
2807
2808
2809
    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
2810
2811
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2812
2813
2814
    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
2815
2816
2817
2818
2819
    auto prog = optimize_onnx("reduce_log_sum_exp_test.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2820
2821
2822
TEST_CASE(reducemax_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2823
2824
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2825
    mm->add_instruction(migraphx::make_op("reduce_max", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2826
    auto prog = optimize_onnx("reducemax_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2827
2828
2829
2830

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2831
TEST_CASE(reducemean_test)
2832
2833
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2834
2835
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2836
2837
    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
2838
    auto prog = optimize_onnx("reducemean_test.onnx");
2839
2840
2841
2842

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2843
TEST_CASE(reducemean_keepdims_test)
2844
2845
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2846
2847
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2848
    mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2849
    auto prog = optimize_onnx("reducemean_keepdims_test.onnx");
2850
2851
2852
2853

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2854
2855
2856
TEST_CASE(reducemin_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2857
2858
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2859
2860
    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
2861
    auto prog = optimize_onnx("reducemin_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
2862
2863
2864
2865

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2866
2867
2868
TEST_CASE(reduceprod_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2869
2870
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2871
    mm->add_instruction(migraphx::make_op("reduce_prod", {{"axes", {2}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2872
2873
2874
2875
2876
    auto prog = optimize_onnx("reduceprod_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2877
TEST_CASE(reducesum_test)
Khalique's avatar
Khalique committed
2878
2879
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2880
2881
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2882
2883
    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
2884
    auto prog = optimize_onnx("reducesum_test.onnx");
2885
2886

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

Shucai Xiao's avatar
Shucai Xiao committed
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
TEST_CASE(reducesum_empty_axes_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    mm->add_literal({});
    auto x  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    auto l1 = mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {0, 1, 2, 3}}}), x);
    auto r  = mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {0, 1, 2, 3}}}), l1);
    mm->add_return({r});

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

    EXPECT(p == prog);
}

TEST_CASE(reducesum_noop_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    mm->add_literal({});
    auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
    mm->add_return({x});
    auto prog = migraphx::parse_onnx("reducesum_noop_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2916
TEST_CASE(reducesum_multiaxis_test)
Khalique's avatar
Khalique committed
2917
2918
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2919
2920
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2921
2922
    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
2923
    auto prog = optimize_onnx("reducesum_multiaxis_test.onnx");
2924
2925

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

Khalique's avatar
Khalique committed
2928
TEST_CASE(reducesum_keepdims_test)
Khalique's avatar
Khalique committed
2929
2930
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2931
2932
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2933
    mm->add_instruction(migraphx::make_op("reduce_sum", {{"axes", {2, 3}}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
2934
    auto prog = optimize_onnx("reducesum_keepdims_test.onnx");
2935
2936
2937
2938

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
2939
2940
2941
TEST_CASE(reducesum_square_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2942
2943
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
2944
2945
2946
    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
2947
2948
2949
2950
2951
    auto prog = optimize_onnx("reducesum_square_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
2952
TEST_CASE(reshape_test)
2953
{
Khalique's avatar
Khalique committed
2954
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2955
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2956
2957
    migraphx::op::reshape op;
    std::vector<int64_t> reshape_dims{3, 8};
Shucai Xiao's avatar
Shucai Xiao committed
2958
    mm->add_literal(
Khalique's avatar
Khalique committed
2959
        migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, reshape_dims});
Shucai Xiao's avatar
Shucai Xiao committed
2960
    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {4, 2, 3}});
Khalique's avatar
Khalique committed
2961
    op.dims = reshape_dims;
Shucai Xiao's avatar
Shucai Xiao committed
2962
2963
    mm->add_instruction(op, l0);
    mm->add_instruction(op, l0);
Shucai Xiao's avatar
Shucai Xiao committed
2964
    auto prog = optimize_onnx("reshape_test.onnx");
2965
2966

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

Khalique's avatar
Khalique committed
2969
TEST_CASE(reshape_non_standard_test)
2970
2971
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
2972
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2973
2974
2975
    migraphx::op::reshape op;
    std::vector<int64_t> reshape_dims{4, 3, 2};
    migraphx::shape s{migraphx::shape::float_type, {2, 3, 4}};
2976
2977
2978
    auto x = mm->add_parameter("x", s);
    auto tran_x =
        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 1}}}), x);
2979
2980
    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
2981
    auto prog = optimize_onnx("reshape_non_standard_test.onnx");
2982
2983
2984
2985

    EXPECT(p == prog);
}

2986
TEST_CASE(resize_downsample_c_test)
Shucai Xiao's avatar
Shucai Xiao committed
2987
2988
{
    migraphx::program p;
2989
2990
    auto* mm = p.get_main_module();

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

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

2998
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
2999
3000

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

3004
3005
    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);
3006
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
3007

3008
    auto prog = migraphx::parse_onnx("resize_downsample_c_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
3009
3010
3011
3012

    EXPECT(p == prog);
}

3013
TEST_CASE(resize_downsample_f_test)
Shucai Xiao's avatar
Shucai Xiao committed
3014
3015
{
    migraphx::program p;
3016
    auto* mm              = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
3017
3018
    std::vector<float> ds = {1.0f, 1.0f, 0.6f, 0.6f};
    migraphx::shape ss{migraphx::shape::float_type, {4}};
3019
    mm->add_literal(migraphx::literal{ss, ds});
Shucai Xiao's avatar
Shucai Xiao committed
3020
3021

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

3024
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
3025
3026

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

3030
3031
    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);
3032
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
3033

3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
    auto prog = migraphx::parse_onnx("resize_downsample_f_test.onnx");

    EXPECT(p == prog);
}

TEST_CASE(resize_downsample_linear_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape ss{migraphx::shape::float_type, {4}};
    std::vector<float> ds = {1, 1, 0.6, 0.5};
    mm->add_literal(migraphx::literal(ss, ds));

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 4}};
    auto x = mm->add_parameter("X", sx);
    migraphx::shape s_ind{migraphx::shape::int32_type, {16, 1, 1, 2}};
    std::vector<int> d_ind = {0, 2, 0, 2, 0, 2, 0, 2, 4, 6, 4, 6, 4, 6, 4, 6,
                              1, 3, 1, 3, 1, 3, 1, 3, 5, 7, 5, 7, 5, 7, 5, 7};
    auto l_ind             = mm->add_literal(migraphx::literal(s_ind, d_ind));

    migraphx::shape s8{migraphx::shape::float_type, {8, 1, 1, 2}};
    std::vector<float> d8(16, 0.5f);
    auto l8 = mm->add_literal(migraphx::literal(s8, d8));

    migraphx::shape s4{migraphx::shape::float_type, {4, 1, 1, 2}};
    std::vector<float> d4(8, 1.0f / 3.0f);
    auto l4 = mm->add_literal(migraphx::literal(s4, d4));

    migraphx::shape s2{migraphx::shape::float_type, {2, 1, 1, 2}};
    std::vector<float> d2(4, 0);
    auto l2 = mm->add_literal(migraphx::literal(s2, d2));
Shucai Xiao's avatar
Shucai Xiao committed
3065

3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
    migraphx::shape s1{migraphx::shape::float_type, {1, 1, 1, 2}};
    std::vector<float> d1(2, 0.0f);
    auto l1 = mm->add_literal(migraphx::literal(s1, d1));

    mm->add_instruction(migraphx::make_op("undefined"));
    auto rsp   = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {8}}}), x);
    auto data  = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), rsp, l_ind);
    auto slc80 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {8}}}), data);
    auto slc81 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {8}}, {"ends", {16}}}), data);
    auto diff8 = mm->add_instruction(migraphx::make_op("sub"), slc81, slc80);
    auto mul8  = mm->add_instruction(migraphx::make_op("mul"), diff8, l8);
    auto add8  = mm->add_instruction(migraphx::make_op("add"), mul8, slc80);
    auto slc40 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {4}}}), add8);
    auto slc41 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {4}}, {"ends", {8}}}), add8);
    auto diff4 = mm->add_instruction(migraphx::make_op("sub"), slc41, slc40);
    auto mul4  = mm->add_instruction(migraphx::make_op("mul"), diff4, l4);
    auto add4  = mm->add_instruction(migraphx::make_op("add"), mul4, slc40);
    auto slc20 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {2}}}), add4);
    auto slc21 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {2}}, {"ends", {4}}}), add4);
    auto diff2 = mm->add_instruction(migraphx::make_op("sub"), slc21, slc20);
    auto mul2  = mm->add_instruction(migraphx::make_op("mul"), diff2, l2);
    auto add2  = mm->add_instruction(migraphx::make_op("add"), mul2, slc20);
    auto slc10 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {1}}}), add2);
    auto slc11 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {1}}, {"ends", {2}}}), add2);
    auto diff1 = mm->add_instruction(migraphx::make_op("sub"), slc11, slc10);
    auto mul1  = mm->add_instruction(migraphx::make_op("mul"), diff1, l1);
    auto add1  = mm->add_instruction(migraphx::make_op("add"), mul1, slc10);
    mm->add_return({add1});

    auto prog = migraphx::parse_onnx("resize_downsample_linear_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
3104
3105
3106
3107
3108
3109
    EXPECT(p == prog);
}

TEST_CASE(resize_outsize_test)
{
    migraphx::program p;
3110
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
3111
3112
3113

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

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

3119
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
3120
3121
3122

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

3125
3126
    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);
3127
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
3128
3129
3130
3131
3132
3133

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

    EXPECT(p == prog);
}

3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147
3148
3149
TEST_CASE(resize_nonstd_input_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();

    std::vector<float> ds = {1.0f, 1.0f, 0.6f, 0.6f};
    migraphx::shape ss{migraphx::shape::float_type, {4}};
    mm->add_literal(migraphx::literal{ss, ds});

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 4, 2}};
    auto inx = mm->add_parameter("X", sx);

    migraphx::shape si{migraphx::shape::int32_type, {1, 1, 1, 2}};
    std::vector<int> ind = {0, 4};
    auto li              = mm->add_literal(migraphx::literal(si, ind));

3150
3151
    auto tx =
        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), inx);
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
    mm->add_instruction(migraphx::make_op("undefined"));
    auto tx_cont = mm->add_instruction(migraphx::make_op("contiguous"), tx);

    auto lrsp = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {8}}}), tx_cont);
    auto r    = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), lrsp, li);
    mm->add_return({r});

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

    EXPECT(p == prog);
}

3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
TEST_CASE(resize_upsample_linear_ac_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape ss{migraphx::shape::float_type, {4}};
    std::vector<float> ds = {1, 1, 2, 2};
    mm->add_literal(migraphx::literal(ss, ds));

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
    auto x = mm->add_parameter("X", sx);
    migraphx::shape s_ind{migraphx::shape::int32_type, {16, 1, 4, 4}};
    std::vector<int> d_ind = {
        0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 2, 2, 2, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 2,
        2, 2, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 2, 2, 2, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
        0, 1, 2, 2, 2, 3, 0, 0, 0, 1, 2, 2, 2, 3, 2, 2, 2, 3, 2, 2, 2, 3, 0, 0, 0, 1, 2, 2, 2,
        3, 2, 2, 2, 3, 2, 2, 2, 3, 0, 0, 0, 1, 2, 2, 2, 3, 2, 2, 2, 3, 2, 2, 2, 3, 0, 0, 0, 1,
        2, 2, 2, 3, 2, 2, 2, 3, 2, 2, 2, 3, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 2, 3, 3, 3, 0,
        1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 2, 3, 3, 3, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 2, 3,
        3, 3, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 2, 3, 3, 3, 0, 1, 1, 1, 2, 3, 3, 3, 2, 3, 3,
        3, 2, 3, 3, 3, 0, 1, 1, 1, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 0, 1, 1, 1, 2, 3, 3, 3,
        2, 3, 3, 3, 2, 3, 3, 3, 0, 1, 1, 1, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3};
    auto l_ind = mm->add_literal(migraphx::literal(s_ind, d_ind));

    migraphx::shape s8{migraphx::shape::float_type, {8, 1, 4, 4}};
    std::vector<float> d8 = {
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0};
    auto l8 = mm->add_literal(migraphx::literal(s8, d8));

    migraphx::shape s4{migraphx::shape::float_type, {4, 1, 4, 4}};
    std::vector<float> d4 = {
        0,        0,        0,        0,        1.0f / 3, 1.0f / 3, 1.0f / 3, 1.0f / 3,
        2.0f / 3, 2.0f / 3, 2.0f / 3, 2.0f / 3, 0,        0,        0,        0,
        0,        0,        0,        0,        1.0f / 3, 1.0f / 3, 1.0f / 3, 1.0f / 3,
        2.0f / 3, 2.0f / 3, 2.0f / 3, 2.0f / 3, 0,        0,        0,        0,
        0,        0,        0,        0,        1.0f / 3, 1.0f / 3, 1.0f / 3, 1.0f / 3,
        2.0f / 3, 2.0f / 3, 2.0f / 3, 2.0f / 3, 0,        0,        0,        0,
        0,        0,        0,        0,        1.0f / 3, 1.0f / 3, 1.0f / 3, 1.0f / 3,
        2.0f / 3, 2.0f / 3, 2.0f / 3, 2.0f / 3, 0,        0,        0,        0};
    auto l4 = mm->add_literal(migraphx::literal(s4, d4));

    migraphx::shape s2{migraphx::shape::float_type, {2, 1, 4, 4}};
    std::vector<float> d2(32, 0);
    auto l2 = mm->add_literal(migraphx::literal(s2, d2));

    migraphx::shape s1{migraphx::shape::float_type, {1, 1, 4, 4}};
    std::vector<float> d1(16, 0.0f);
    auto l1 = mm->add_literal(migraphx::literal(s1, d1));

    mm->add_instruction(migraphx::make_op("undefined"));
    auto rsp   = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {4}}}), x);
    auto data  = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), rsp, l_ind);
    auto slc80 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {8}}}), data);
    auto slc81 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {8}}, {"ends", {16}}}), data);
    auto diff8 = mm->add_instruction(migraphx::make_op("sub"), slc81, slc80);
    auto mul8  = mm->add_instruction(migraphx::make_op("mul"), diff8, l8);
    auto add8  = mm->add_instruction(migraphx::make_op("add"), mul8, slc80);
    auto slc40 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {4}}}), add8);
    auto slc41 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {4}}, {"ends", {8}}}), add8);
    auto diff4 = mm->add_instruction(migraphx::make_op("sub"), slc41, slc40);
    auto mul4  = mm->add_instruction(migraphx::make_op("mul"), diff4, l4);
    auto add4  = mm->add_instruction(migraphx::make_op("add"), mul4, slc40);
    auto slc20 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {2}}}), add4);
    auto slc21 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {2}}, {"ends", {4}}}), add4);
    auto diff2 = mm->add_instruction(migraphx::make_op("sub"), slc21, slc20);
    auto mul2  = mm->add_instruction(migraphx::make_op("mul"), diff2, l2);
    auto add2  = mm->add_instruction(migraphx::make_op("add"), mul2, slc20);
    auto slc10 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {1}}}), add2);
    auto slc11 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {1}}, {"ends", {2}}}), add2);
    auto diff1 = mm->add_instruction(migraphx::make_op("sub"), slc11, slc10);
    auto mul1  = mm->add_instruction(migraphx::make_op("mul"), diff1, l1);
    auto add1  = mm->add_instruction(migraphx::make_op("add"), mul1, slc10);
    mm->add_return({add1});

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

TEST_CASE(resize_upsample_linear_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape ss{migraphx::shape::float_type, {4}};
    std::vector<float> ds = {1, 1, 2, 2};
    mm->add_literal(migraphx::literal(ss, ds));

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
    auto x = mm->add_parameter("X", sx);
    migraphx::shape s_ind{migraphx::shape::int32_type, {16, 1, 4, 4}};
    std::vector<int> d_ind = {
        0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 2, 2, 2, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 2,
        2, 2, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 2, 2, 2, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
        0, 1, 2, 2, 2, 3, 0, 0, 0, 1, 2, 2, 2, 3, 2, 2, 2, 3, 2, 2, 2, 3, 0, 0, 0, 1, 2, 2, 2,
        3, 2, 2, 2, 3, 2, 2, 2, 3, 0, 0, 0, 1, 2, 2, 2, 3, 2, 2, 2, 3, 2, 2, 2, 3, 0, 0, 0, 1,
        2, 2, 2, 3, 2, 2, 2, 3, 2, 2, 2, 3, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 2, 3, 3, 3, 0,
        1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 2, 3, 3, 3, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 2, 3,
        3, 3, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 2, 3, 3, 3, 0, 1, 1, 1, 2, 3, 3, 3, 2, 3, 3,
        3, 2, 3, 3, 3, 0, 1, 1, 1, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 0, 1, 1, 1, 2, 3, 3, 3,
        2, 3, 3, 3, 2, 3, 3, 3, 0, 1, 1, 1, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3};
    auto l_ind = mm->add_literal(migraphx::literal(s_ind, d_ind));

    migraphx::shape s8{migraphx::shape::float_type, {8, 1, 4, 4}};
    std::vector<float> d8 = {
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0,
        0, 1.0f / 3, 2.0f / 3, 0, 0, 1.0f / 3, 2.0f / 3, 0};
    auto l8 = mm->add_literal(migraphx::literal(s8, d8));

    migraphx::shape s4{migraphx::shape::float_type, {4, 1, 4, 4}};
    std::vector<float> d4 = {
        0,        0,        0,        0,        1.0f / 3, 1.0f / 3, 1.0f / 3, 1.0f / 3,
        2.0f / 3, 2.0f / 3, 2.0f / 3, 2.0f / 3, 0,        0,        0,        0,
        0,        0,        0,        0,        1.0f / 3, 1.0f / 3, 1.0f / 3, 1.0f / 3,
        2.0f / 3, 2.0f / 3, 2.0f / 3, 2.0f / 3, 0,        0,        0,        0,
        0,        0,        0,        0,        1.0f / 3, 1.0f / 3, 1.0f / 3, 1.0f / 3,
        2.0f / 3, 2.0f / 3, 2.0f / 3, 2.0f / 3, 0,        0,        0,        0,
        0,        0,        0,        0,        1.0f / 3, 1.0f / 3, 1.0f / 3, 1.0f / 3,
        2.0f / 3, 2.0f / 3, 2.0f / 3, 2.0f / 3, 0,        0,        0,        0};
    auto l4 = mm->add_literal(migraphx::literal(s4, d4));

    migraphx::shape s2{migraphx::shape::float_type, {2, 1, 4, 4}};
    std::vector<float> d2(32, 0);
    auto l2 = mm->add_literal(migraphx::literal(s2, d2));

    migraphx::shape s1{migraphx::shape::float_type, {1, 1, 4, 4}};
    std::vector<float> d1(16, 0.0f);
    auto l1 = mm->add_literal(migraphx::literal(s1, d1));

    mm->add_instruction(migraphx::make_op("undefined"));
    auto rsp   = mm->add_instruction(migraphx::make_op("reshape", {{"dims", {4}}}), x);
    auto data  = mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), rsp, l_ind);
    auto slc80 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {8}}}), data);
    auto slc81 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {8}}, {"ends", {16}}}), data);
    auto diff8 = mm->add_instruction(migraphx::make_op("sub"), slc81, slc80);
    auto mul8  = mm->add_instruction(migraphx::make_op("mul"), diff8, l8);
    auto add8  = mm->add_instruction(migraphx::make_op("add"), mul8, slc80);
    auto slc40 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {4}}}), add8);
    auto slc41 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {4}}, {"ends", {8}}}), add8);
    auto diff4 = mm->add_instruction(migraphx::make_op("sub"), slc41, slc40);
    auto mul4  = mm->add_instruction(migraphx::make_op("mul"), diff4, l4);
    auto add4  = mm->add_instruction(migraphx::make_op("add"), mul4, slc40);
    auto slc20 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {2}}}), add4);
    auto slc21 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {2}}, {"ends", {4}}}), add4);
    auto diff2 = mm->add_instruction(migraphx::make_op("sub"), slc21, slc20);
    auto mul2  = mm->add_instruction(migraphx::make_op("mul"), diff2, l2);
    auto add2  = mm->add_instruction(migraphx::make_op("add"), mul2, slc20);
    auto slc10 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {0}}, {"ends", {1}}}), add2);
    auto slc11 = mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0}}, {"starts", {1}}, {"ends", {2}}}), add2);
    auto diff1 = mm->add_instruction(migraphx::make_op("sub"), slc11, slc10);
    auto mul1  = mm->add_instruction(migraphx::make_op("mul"), diff1, l1);
    auto add1  = mm->add_instruction(migraphx::make_op("add"), mul1, slc10);
    mm->add_return({add1});

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

Shucai Xiao's avatar
Shucai Xiao committed
3354
3355
3356
TEST_CASE(resize_upsample_pc_test)
{
    migraphx::program p;
3357
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
3358
3359
3360

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

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

3366
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
3367
3368
3369

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

3372
3373
    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);
3374
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
3375
3376
3377
3378
3379
3380
3381
3382
3383

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

    EXPECT(p == prog);
}

TEST_CASE(resize_upsample_pf_test)
{
    migraphx::program p;
3384
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
3385
3386
3387

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

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

3393
    mm->add_instruction(migraphx::make_op("undefined"));
Shucai Xiao's avatar
Shucai Xiao committed
3394
3395
3396

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

3399
3400
    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);
3401
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
3402
3403
3404
3405
3406
3407

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3408
3409
3410
TEST_CASE(round_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3411
3412
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
3413
    mm->add_instruction(migraphx::make_op("round"), input);
Khalique's avatar
Khalique committed
3414

Shucai Xiao's avatar
Shucai Xiao committed
3415
    auto prog = optimize_onnx("round_test.onnx");
Khalique's avatar
Khalique committed
3416
3417
3418
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
3419
3420
3421
3422
3423
TEST_CASE(scatter_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto l0 = mm->add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
Shucai Xiao's avatar
Shucai Xiao committed
3424
3425
3426
3427
    auto l1 =
        mm->add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 3, 4, 5}});
    auto l2 =
        mm->add_parameter("update", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
Shucai Xiao's avatar
Shucai Xiao committed
3428
    int axis = -2;
Shucai Xiao's avatar
Shucai Xiao committed
3429
    auto r   = mm->add_instruction(migraphx::make_op("scatter", {{"axis", axis}}), l0, l1, l2);
Shucai Xiao's avatar
Shucai Xiao committed
3430
3431
3432
3433
3434
3435
    mm->add_return({r});
    auto prog = migraphx::parse_onnx("scatter_test.onnx");

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
3436
3437
3438
TEST_CASE(selu_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3439
    auto* mm                      = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
3440
3441
    std::vector<std::size_t> lens = {2, 3};
    migraphx::shape s{migraphx::shape::double_type, lens};
Shucai Xiao's avatar
Shucai Xiao committed
3442
    auto x = mm->add_parameter("x", s);
Shucai Xiao's avatar
Shucai Xiao committed
3443
3444

    migraphx::shape ls{migraphx::shape::double_type, {1}};
3445
3446
3447
3448
    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", {{"out_lens", lens}}), la);
    auto mblg = mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", lens}}), lg);
Shucai Xiao's avatar
Shucai Xiao committed
3449

3450
3451
    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
3452

3453
3454
    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
3455

3456
3457
    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
3458

3459
3460
3461
    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
3462
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
3463
3464
3465
3466
3467
3468

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3469
TEST_CASE(shape_test)
3470
3471
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3472
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
3473
    migraphx::shape s{migraphx::shape::float_type, {3, 4, 5, 6}};
Shucai Xiao's avatar
Shucai Xiao committed
3474
    auto l0 = mm->add_parameter("x", s);
Khalique's avatar
Khalique committed
3475
    migraphx::shape s_shape{migraphx::shape::int64_type, {4}};
Shucai Xiao's avatar
Shucai Xiao committed
3476
    mm->add_literal(s_shape, l0->get_shape().lens());
Shucai Xiao's avatar
Shucai Xiao committed
3477
    auto prog = optimize_onnx("shape_test.onnx");
3478
3479
3480
3481

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3482
TEST_CASE(shape_gather_test)
3483
3484
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3485
3486
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {7, 3, 10}});
3487
    migraphx::shape const_shape{migraphx::shape::int32_type, {1}};
Shucai Xiao's avatar
Shucai Xiao committed
3488
    auto l2 = mm->add_literal(migraphx::literal{const_shape, {1}});
Khalique's avatar
Khalique committed
3489
    auto l1 =
Shucai Xiao's avatar
Shucai Xiao committed
3490
        mm->add_literal(migraphx::shape{migraphx::shape::int64_type, {3}}, l0->get_shape().lens());
Khalique's avatar
Khalique committed
3491
    int axis = 0;
3492
    mm->add_instruction(migraphx::make_op("gather", {{"axis", axis}}), l1, l2);
Shucai Xiao's avatar
Shucai Xiao committed
3493
    auto prog = optimize_onnx("shape_gather_test.onnx");
3494
3495
3496
3497

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3498
TEST_CASE(sign_test)
Khalique's avatar
Khalique committed
3499
3500
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3501
3502
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
3503
    mm->add_instruction(migraphx::make_op("sign"), input);
Khalique's avatar
Khalique committed
3504

Shucai Xiao's avatar
Shucai Xiao committed
3505
    auto prog = optimize_onnx("sign_test.onnx");
Khalique's avatar
Khalique committed
3506
3507
3508
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3509
TEST_CASE(sin_test)
3510
3511
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3512
3513
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
3514
    mm->add_instruction(migraphx::make_op("sin"), input);
3515

Shucai Xiao's avatar
Shucai Xiao committed
3516
    auto prog = optimize_onnx("sin_test.onnx");
3517
3518
3519
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3520
TEST_CASE(sinh_test)
3521
3522
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3523
3524
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
3525
    mm->add_instruction(migraphx::make_op("sinh"), input);
Khalique's avatar
Khalique committed
3526

Shucai Xiao's avatar
Shucai Xiao committed
3527
    auto prog = optimize_onnx("sinh_test.onnx");
3528
3529
3530
3531

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
3532
3533
3534
TEST_CASE(slice_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3535
3536
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 2}});
3537
3538
    mm->add_instruction(
        migraphx::make_op("slice", {{"axes", {0, 1}}, {"starts", {1, 0}}, {"ends", {2, 2}}}), l0);
kahmed10's avatar
kahmed10 committed
3539
3540
3541
3542
3543
3544
3545
3546
    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
3547
3548
3549
3550
    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}});
3551
3552
    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
3553
    mm->add_return({ret});
kahmed10's avatar
kahmed10 committed
3554
3555
3556
3557
3558
3559

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
3560
3561
3562
TEST_CASE(slice_5arg_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3563
3564
3565
3566
3567
3568
    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}});
3569
3570
3571
    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
3572
    mm->add_return({ret});
Shucai Xiao's avatar
Shucai Xiao committed
3573
3574
3575
3576
3577
3578

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

    EXPECT(p == prog);
}

Cagri Eryilmaz's avatar
Cagri Eryilmaz committed
3579
3580
3581
3582
3583
3584
3585
TEST_CASE(slice_5arg_reverse_test)
{
    migraphx::program p;
    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}});
3586
3587
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {-5, -1}});
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {-1, -3}});
Cagri Eryilmaz's avatar
Cagri Eryilmaz committed
3588
    auto slice_out = mm->add_instruction(
3589
3590
        migraphx::make_op("slice",
                          {{"axes", {-1, -2}}, {"starts", {-4, -3}}, {"ends", {2147483647, -1}}}),
Cagri Eryilmaz's avatar
Cagri Eryilmaz committed
3591
3592
3593
3594
3595
3596
3597
3598
3599
        l0);
    auto ret = mm->add_instruction(migraphx::make_op("reverse", {{"axes", {-1}}}), slice_out);
    mm->add_return({ret});

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

    EXPECT(p == prog);
}

3600
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621
3622
3623
TEST_CASE(slice_5arg_step_test)
{
    migraphx::program p;
    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}}, {-2, 2}});
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {-1, -2}});
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {-5, -1}});
    mm->add_literal({{migraphx::shape::int32_type, {2}}, {-1, -3}});
    auto slice_out = mm->add_instruction(
        migraphx::make_op("slice",
                          {{"axes", {-1, -2}}, {"starts", {-4, -3}}, {"ends", {2147483647, -1}}}),
        l0);
    auto reverse_out =
        mm->add_instruction(migraphx::make_op("reverse", {{"axes", {-1}}}), slice_out);
    auto step_out = mm->add_instruction(
        migraphx::make_op("step", {{"axes", {-1, -2}}, {"steps", {2, 2}}}), reverse_out);
    mm->add_return({step_out});

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

    EXPECT(p == prog);
}

3624
3625
3626
TEST_CASE(slice_max_end_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3627
3628
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {10, 20}});
3629
3630
3631
3632
    mm->add_instruction(
        migraphx::make_op("slice",
                          {{"axes", {0, 1}}, {"starts", {1, 2}}, {"ends", {3000000000, -1}}}),
        l0);
3633
3634
3635
3636
3637
    auto prog = optimize_onnx("slice_max_end_test.onnx");

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3638
TEST_CASE(softmax_test)
Shucai Xiao's avatar
Shucai Xiao committed
3639
3640
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3641
3642
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
3643
    mm->add_instruction(migraphx::make_op("softmax", {{"axis", 1}}), l0);
Shucai Xiao's avatar
Shucai Xiao committed
3644
    auto prog = optimize_onnx("softmax_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
3645
3646
3647
3648

    EXPECT(p == prog);
}

3649
3650
3651
3652
3653
3654
3655
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);
Shucai Xiao's avatar
Shucai Xiao committed
3656
    auto l2 = mm->add_instruction(migraphx::make_op("softmax", {{"axis", -1}}), l1);
3657
3658
3659
3660
3661
3662
3663
    mm->add_return({l2});

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
3664
3665
3666
TEST_CASE(split_minus_axis_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3667
3668
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
3669
3670
3671
3672
3673
3674
    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
3675
    mm->add_return({r1, r2, r3});
Shucai Xiao's avatar
Shucai Xiao committed
3676
3677
3678
3679
3680
3681

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

    EXPECT(p == prog);
}

3682
3683
3684
TEST_CASE(split_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3685
3686
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
3687
3688
3689
3690
3691
3692
    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
3693
    mm->add_return({r1, r2, r3});
3694
3695
3696
3697
3698
3699
3700
3701

    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
3702
3703
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
3704
3705
3706
3707
    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
3708
    mm->add_return({r1, r2});
3709
3710
3711
3712
3713

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

Khalique's avatar
Khalique committed
3714
TEST_CASE(sqrt_test)
Shucai Xiao's avatar
Shucai Xiao committed
3715
3716
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3717
3718
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
3719
    mm->add_instruction(migraphx::make_op("sqrt"), input);
Shucai Xiao's avatar
Shucai Xiao committed
3720

Shucai Xiao's avatar
Shucai Xiao committed
3721
    auto prog = optimize_onnx("sqrt_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
3722
3723
3724
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3725
TEST_CASE(squeeze_unsqueeze_test)
Khalique's avatar
Khalique committed
3726
3727
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3728
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
3729
3730
3731
    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
3732
        mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 1, 1, 2, 1}});
3733
3734
    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
3735
    auto prog = optimize_onnx("squeeze_unsqueeze_test.onnx");
Khalique's avatar
Khalique committed
3736
3737
3738
3739

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
TEST_CASE(squeeze_axes_input_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    mm->add_literal(migraphx::literal({migraphx::shape::int64_type, {2}}, {1, 3}));
    auto l0 = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 1, 5, 1}});
    auto l1 = mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {1, 3}}}), l0);
    mm->add_return({l1});

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

    EXPECT(p == prog);
}

TEST_CASE(squeeze_empty_axes_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    mm->add_literal({});
    auto l0 = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 1, 5, 1}});
    auto l1 = mm->add_instruction(migraphx::make_op("squeeze"), l0);
    mm->add_return({l1});

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3768
TEST_CASE(sub_bcast_test)
Shucai Xiao's avatar
Shucai Xiao committed
3769
3770
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3771
3772
3773
    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}});
3774
    auto l2  = mm->add_instruction(
3775
        migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", l0->get_shape().lens()}}), l1);
3776
    mm->add_instruction(migraphx::make_op("sub"), l0, l2);
Shucai Xiao's avatar
Shucai Xiao committed
3777

Shucai Xiao's avatar
Shucai Xiao committed
3778
    auto prog = optimize_onnx("sub_bcast_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
3779
3780
3781
3782

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3783
TEST_CASE(sub_scalar_test)
Shucai Xiao's avatar
Shucai Xiao committed
3784
3785
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3786
3787
3788
    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}});
3789
3790
    auto m1 =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 4, 5}}}), l1);
3791
    mm->add_instruction(migraphx::make_op("sub"), l0, m1);
Shucai Xiao's avatar
Shucai Xiao committed
3792
    auto prog = optimize_onnx("sub_scalar_test.onnx");
Shucai Xiao's avatar
Shucai Xiao committed
3793
3794
3795
3796

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
3797
3798
3799
TEST_CASE(sum_int_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3800
3801
3802
3803
    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}});
3804
3805
3806
3807
3808
3809
3810
3811
3812
3813
    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
3814
3815
3816
3817
3818

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

Khalique's avatar
Khalique committed
3819
TEST_CASE(sum_test)
3820
3821
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3822
3823
3824
3825
    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}});
3826
3827
    auto l0     = mm->add_instruction(migraphx::make_op("add"), input0, input1);
    mm->add_instruction(migraphx::make_op("add"), l0, input2);
3828

Shucai Xiao's avatar
Shucai Xiao committed
3829
    auto prog = optimize_onnx("sum_test.onnx");
3830
3831
3832
    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
3833
3834
3835
TEST_CASE(sum_type_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3836
3837
3838
3839
3840
3841
3842
3843
3844
    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}});
3845
3846
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
3873
3874
3875
    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
3876
    mm->add_return({s6});
Shucai Xiao's avatar
Shucai Xiao committed
3877
3878
3879
3880
3881
3882

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3883
TEST_CASE(tan_test)
3884
3885
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3886
3887
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
3888
    mm->add_instruction(migraphx::make_op("tan"), input);
3889

Shucai Xiao's avatar
Shucai Xiao committed
3890
    auto prog = optimize_onnx("tan_test.onnx");
3891
3892
3893
    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
3894
TEST_CASE(tanh_test)
3895
3896
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3897
3898
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}});
3899
    mm->add_instruction(migraphx::make_op("tanh"), input);
3900

Shucai Xiao's avatar
Shucai Xiao committed
3901
    auto prog = optimize_onnx("tanh_test.onnx");
3902
3903
3904
3905

    EXPECT(p == prog);
}

3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947
3948
3949
3950
3951
3952
3953
3954
3955
3956
3957
3958
3959
3960
3961
3962
TEST_CASE(thresholdedrelu_default_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto x   = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2, 2, 3}});
    auto lz  = mm->add_literal(migraphx::literal{migraphx::shape{x->get_shape().type()}, {0}});
    auto la  = mm->add_literal(migraphx::literal{migraphx::shape{x->get_shape().type()}, {1.0f}});
    auto mbz = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"out_lens", x->get_shape().lens()}}), lz);
    auto mba = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"out_lens", x->get_shape().lens()}}), la);
    auto condition = mm->add_instruction(migraphx::make_op("greater"), x, mba);
    mm->add_instruction(migraphx::make_op("where"), condition, x, mbz);

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

    EXPECT(p == prog);
}

TEST_CASE(thresholdedrelu_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto x   = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2, 2, 3}});
    auto lz  = mm->add_literal(migraphx::literal{migraphx::shape{x->get_shape().type()}, {0}});
    auto la  = mm->add_literal(migraphx::literal{migraphx::shape{x->get_shape().type()}, {3.0f}});
    auto mbz = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"out_lens", x->get_shape().lens()}}), lz);
    auto mba = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"out_lens", x->get_shape().lens()}}), la);
    auto condition = mm->add_instruction(migraphx::make_op("greater"), x, mba);
    mm->add_instruction(migraphx::make_op("where"), condition, x, mbz);

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

    EXPECT(p == prog);
}

TEST_CASE(thresholdedrelu_int_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    auto x   = mm->add_parameter("x", migraphx::shape{migraphx::shape::int32_type, {2, 2, 3}});
    auto lz  = mm->add_literal(migraphx::literal{migraphx::shape{x->get_shape().type()}, {0}});
    auto la  = mm->add_literal(migraphx::literal{migraphx::shape{x->get_shape().type()}, {3}});
    auto mbz = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"out_lens", x->get_shape().lens()}}), lz);
    auto mba = mm->add_instruction(
        migraphx::make_op("multibroadcast", {{"out_lens", x->get_shape().lens()}}), la);
    auto condition = mm->add_instruction(migraphx::make_op("greater"), x, mba);
    mm->add_instruction(migraphx::make_op("where"), condition, x, mbz);

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

    EXPECT(p == prog);
}

kahmed10's avatar
kahmed10 committed
3963
3964
3965
TEST_CASE(tile_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
3966
3967
3968
    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}});
3969
    mm->add_instruction(migraphx::make_op("concat", {{"axis", 1}}), input, input);
kahmed10's avatar
kahmed10 committed
3970
3971
3972
3973
3974
3975
3976
3977
3978

    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
3979
3980
3981
    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}});
3982
3983
3984
    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
3985
3986
3987
3988
3989
3990

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

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
3991
3992
3993
3994
3995
3996
3997
3998
3999
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
TEST_CASE(transpose_default_perm_test)
{
    migraphx::program p;
    auto* mm   = p.get_main_module();
    auto input = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 5, 2, 3}});
    std::vector<int64_t> perm{3, 2, 1, 0};
    auto r = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), input);
    mm->add_return({r});

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

    EXPECT(p == prog);
}

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

Khalique's avatar
Khalique committed
4010
TEST_CASE(transpose_test)
4011
4012
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
4013
4014
    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
4015
    std::vector<int64_t> perm{0, 3, 1, 2};
4016
    mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), input);
Khalique's avatar
Khalique committed
4017

Shucai Xiao's avatar
Shucai Xiao committed
4018
    auto prog = optimize_onnx("transpose_test.onnx");
4019
4020
4021
4022

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051
4052
4053
4054
4055
4056
4057
4058
4059
4060
4061
4062
4063
4064
4065
4066
4067
4068
4069
4070
4071
4072
4073
4074
4075
4076
TEST_CASE(topk_attrk_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape s{migraphx::shape::float_type, {2, 5, 3, 2}};
    auto data = mm->add_parameter("data", s);
    auto out  = mm->add_instruction(migraphx::make_op("topk", {{"k", 2}, {"axis", -1}}), data);
    auto val  = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), out);
    auto ind  = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), out);
    mm->add_return({val, ind});

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

    EXPECT(p == prog);
}

TEST_CASE(topk_neg_axis_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape sk{migraphx::shape::int64_type, {1}};
    mm->add_literal(migraphx::literal(sk, {3}));
    migraphx::shape s{migraphx::shape::float_type, {3, 4, 5, 6}};
    auto data = mm->add_parameter("data", s);
    auto out  = mm->add_instruction(
        migraphx::make_op("topk", {{"k", 3}, {"axis", -2}, {"largest", 1}}), data);
    auto val = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), out);
    auto ind = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), out);
    mm->add_return({val, ind});

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

    EXPECT(p == prog);
}

TEST_CASE(topk_test)
{
    migraphx::program p;
    auto* mm = p.get_main_module();
    migraphx::shape sk{migraphx::shape::int64_type, {1}};
    mm->add_literal(migraphx::literal(sk, {4}));
    migraphx::shape s{migraphx::shape::float_type, {2, 5, 3, 2}};
    auto data = mm->add_parameter("data", s);
    auto out  = mm->add_instruction(
        migraphx::make_op("topk", {{"k", 4}, {"axis", 1}, {"largest", 0}}), data);
    auto val = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), out);
    auto ind = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), out);
    mm->add_return({val, ind});

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
4077
TEST_CASE(transpose_gather_test)
4078
4079
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
4080
4081
    auto* mm             = p.get_main_module();
    auto make_contiguous = [&mm](migraphx::instruction_ref ins) {
Khalique's avatar
Khalique committed
4082
4083
4084
4085
4086
        if(ins->get_shape().standard())
        {
            return ins;
        }

4087
        return mm->add_instruction(migraphx::make_op("contiguous"), ins);
Khalique's avatar
Khalique committed
4088
4089
    };

Shucai Xiao's avatar
Shucai Xiao committed
4090
4091
    auto data =
        mm->add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 5, 4, 6}});
Khalique's avatar
Khalique committed
4092
    auto ind =
Shucai Xiao's avatar
Shucai Xiao committed
4093
        mm->add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 4, 3, 5}});
4094
    auto tr_data =
4095
        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 1, 3}}}), data);
4096
    auto tr_ind =
4097
        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 1, 3}}}), ind);
4098
4099
4100
4101
    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
4102

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

4105
    EXPECT(p.sort() == prog.sort());
4106
4107
}

4108
4109
4110
TEST_CASE(undefined_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
4111
4112
    auto* mm = p.get_main_module();
    mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
4113
4114
    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
4115
    mm->add_return({l2});
4116
4117
4118
4119
4120
4121

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

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
4122
TEST_CASE(unknown_test)
4123
4124
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
4125
4126
4127
4128
4129
    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
4130
    auto prog = optimize_onnx("unknown_test.onnx");
4131
4132
4133
4134

    EXPECT(p == prog);
}

4135
4136
4137
4138
4139
TEST_CASE(unknown_aten_test)
{
    EXPECT(test::throws([&] { migraphx::parse_onnx("unknown_aten_test.onnx"); }));
}

4140
4141
4142
4143
4144
TEST_CASE(unknown_test_throw)
{
    EXPECT(test::throws([&] { migraphx::parse_onnx("unknown_test.onnx"); }));
}

Shucai Xiao's avatar
Shucai Xiao committed
4145
4146
4147
TEST_CASE(upsample_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
4148
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
4149
    migraphx::shape ss{migraphx::shape::float_type, {4}};
Shucai Xiao's avatar
Shucai Xiao committed
4150
    mm->add_literal(migraphx::literal(ss, {1.0f, 1.0f, 2.0f, 3.0f}));
Shucai Xiao's avatar
Shucai Xiao committed
4151
4152

    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
Shucai Xiao's avatar
Shucai Xiao committed
4153
    auto ix = mm->add_parameter("X", sx);
Shucai Xiao's avatar
Shucai Xiao committed
4154
4155
4156
4157

    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
4158
    auto li  = mm->add_literal(migraphx::literal(si, ind));
4159
4160
    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
4161
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
4162
4163
4164
4165
4166
4167

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

    EXPECT(p == prog);
}

4168
4169
4170
4171
4172
4173
4174
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); }));
}

4175
4176
4177
TEST_CASE(variable_batch_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
4178
4179
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
4180
    mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
4181
    auto prog = optimize_onnx("variable_batch_test.onnx");
4182
4183
4184
4185

    EXPECT(p == prog);
}

4186
4187
4188
TEST_CASE(variable_batch_user_input_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
4189
4190
    auto* mm = p.get_main_module();
    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 16, 16}});
4191
    auto r   = mm->add_instruction(migraphx::make_op("identity"), l0);
Shucai Xiao's avatar
Shucai Xiao committed
4192
    mm->add_return({r});
4193
4194
4195
4196
4197
4198
4199
4200
4201

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

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

    EXPECT(p == prog);
}

4202
4203
4204
TEST_CASE(variable_batch_leq_zero_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
4205
4206
4207
    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}});
4208
    mm->add_instruction(migraphx::make_op("add"), l0, l1);
Shucai Xiao's avatar
Shucai Xiao committed
4209
    auto prog = optimize_onnx("variable_batch_leq_zero_test.onnx");
4210
4211
4212
4213

    EXPECT(p == prog);
}

Shucai Xiao's avatar
Shucai Xiao committed
4214
4215
4216
TEST_CASE(where_test)
{
    migraphx::program p;
Shucai Xiao's avatar
Shucai Xiao committed
4217
4218
4219
4220
4221
    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}});

turneram's avatar
turneram committed
4222
4223
    auto lccm =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 2, 2, 2}}}), lc);
4224
4225
4226
4227
    auto lxm =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 2, 2, 2}}}), lx);
    auto lym =
        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 2, 2, 2}}}), ly);
4228

turneram's avatar
turneram committed
4229
    auto r = mm->add_instruction(migraphx::make_op("where"), lccm, lxm, lym);
Shucai Xiao's avatar
Shucai Xiao committed
4230
    mm->add_return({r});
Shucai Xiao's avatar
Shucai Xiao committed
4231
4232
4233
4234
4235
4236

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

    EXPECT(p == prog);
}

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