ref_ops_test.cpp 147 KB
Newer Older
1
2
#include <iostream>
#include <vector>
Paul's avatar
Paul committed
3
4
5
#include <migraphx/literal.hpp>
#include <migraphx/operators.hpp>
#include <migraphx/instruction.hpp>
6
#include <migraphx/quantization.hpp>
7
#include <migraphx/ref/target.hpp>
8
#include <migraphx/quantization.hpp>
Paul's avatar
Paul committed
9
#include <migraphx/verify.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
10
#include <migraphx/onnx.hpp>
11
#include "test.hpp"
12
#include <migraphx/half.hpp>
Scott Thornton's avatar
Scott Thornton committed
13

Khalique's avatar
Khalique committed
14
float sigmoid(float x) { return 1 / (1 + expf(-x)); }
Khalique's avatar
Khalique committed
15

Khalique's avatar
Khalique committed
16
float elu(float a, float x) { return x > 0 ? x : a * std::expm1(x); }
Khalique's avatar
Khalique committed
17

Paul's avatar
Paul committed
18
TEST_CASE(slice_test)
Scott Thornton's avatar
Scott Thornton committed
19
{
Scott Thornton's avatar
Scott Thornton committed
20
    {
Paul's avatar
Paul committed
21
        migraphx::program p;
22
        auto* mm = p.get_main_module();
Scott Thornton's avatar
Scott Thornton committed
23
24
        std::vector<int> data(2 * 2 * 3);
        std::iota(data.begin(), data.end(), 0);
Paul's avatar
Paul committed
25
        migraphx::shape s{migraphx::shape::int32_type, {2, 2, 3}};
26
27
        auto l0 = mm->add_literal(migraphx::literal{s, data});
        mm->add_instruction(migraphx::op::slice{{2}, {1}, {3}}, l0);
Paul's avatar
Paul committed
28
        migraphx::shape s2{migraphx::shape::int32_type, {2, 2, 2}, {6, 3, 1}};
29
        EXPECT(p.get_output_shapes().back() == s2);
30
        p.compile(migraphx::ref::target{});
Paul's avatar
Paul committed
31
        migraphx::shape sresult{migraphx::shape::int32_type, {2, 2, 2}, {4, 2, 1}};
32
        auto result           = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
33
34
35
        std::vector<int> gold = {1, 2, 4, 5, 7, 8, 10, 11};
        std::vector<int> results_vector(2 * 2 * 2);
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
36
        EXPECT(migraphx::verify_range(results_vector, gold));
Scott Thornton's avatar
Scott Thornton committed
37
38
39
        EXPECT(result.get_shape() == sresult);
    }
    {
Paul's avatar
Paul committed
40
        migraphx::program p;
41
        auto* mm = p.get_main_module();
Scott Thornton's avatar
Scott Thornton committed
42
43
        std::vector<int> data(2 * 2 * 3);
        std::iota(data.begin(), data.end(), 0);
Paul's avatar
Paul committed
44
        migraphx::shape s{migraphx::shape::int32_type, {2, 2, 3}};
45
46
        auto l0 = mm->add_literal(migraphx::literal{s, data});
        mm->add_instruction(migraphx::op::slice{{0, 1, 2}, {0, 0, 0}, {2, 2, 2}}, l0);
Paul's avatar
Paul committed
47
        migraphx::shape s2{migraphx::shape::int32_type, {2, 2, 2}, {6, 3, 1}};
48
        EXPECT(p.get_output_shapes().back() == s2);
49
        p.compile(migraphx::ref::target{});
Paul's avatar
Paul committed
50
        migraphx::shape sresult{migraphx::shape::int32_type, {2, 2, 2}, {4, 2, 1}};
51
        auto result           = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
52
53
54
        std::vector<int> gold = {0, 1, 3, 4, 6, 7, 9, 10};
        std::vector<int> results_vector(2 * 2 * 2);
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
55
        EXPECT(migraphx::verify_range(results_vector, gold));
Scott Thornton's avatar
Scott Thornton committed
56
57
        EXPECT(result.get_shape() == sresult);
    }
58
59
}

Paul's avatar
Paul committed
60
TEST_CASE(concat_test)
61
{
Scott Thornton's avatar
Scott Thornton committed
62
    {
Paul's avatar
Paul committed
63
        migraphx::program p;
64
        auto* mm               = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
65
        int axis               = 1;
Scott Thornton's avatar
Scott Thornton committed
66
67
68
        std::vector<int> data0 = {0, 1, 5, 6};
        std::vector<int> data1 = {2, 3, 4, 7, 8, 9};
        std::vector<int> data2 = {10, 20};
Paul's avatar
Paul committed
69
70
71
        migraphx::shape s0{migraphx::shape::int32_type, {2, 2}};
        migraphx::shape s1{migraphx::shape::int32_type, {2, 3}};
        migraphx::shape s2{migraphx::shape::int32_type, {2, 1}};
72
73
74
75
        auto l0 = mm->add_literal(migraphx::literal{s0, data0});
        auto l1 = mm->add_literal(migraphx::literal{s1, data1});
        auto l2 = mm->add_literal(migraphx::literal{s2, data2});
        mm->add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
76
        p.compile(migraphx::ref::target{});
77
        auto result           = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
78
        std::vector<int> gold = {0, 1, 2, 3, 4, 10, 5, 6, 7, 8, 9, 20};
Scott Thornton's avatar
Scott Thornton committed
79
        std::vector<int> results_vector(2 * 6);
Scott Thornton's avatar
Scott Thornton committed
80
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
81
82
        EXPECT(migraphx::verify_range(results_vector, gold));
        EXPECT(migraphx::verify_range(result.get_shape().lens(), std::vector<std::size_t>({2, 6})));
Scott Thornton's avatar
Scott Thornton committed
83
        EXPECT(
Paul's avatar
Paul committed
84
            migraphx::verify_range(result.get_shape().strides(), std::vector<std::size_t>({6, 1})));
Scott Thornton's avatar
Scott Thornton committed
85
    }
Shucai Xiao's avatar
Shucai Xiao committed
86
87
88

    {
        migraphx::program p;
89
        auto* mm               = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
90
91
92
93
94
95
96
        int axis               = -1;
        std::vector<int> data0 = {0, 1, 5, 6};
        std::vector<int> data1 = {2, 3, 4, 7, 8, 9};
        std::vector<int> data2 = {10, 20};
        migraphx::shape s0{migraphx::shape::int32_type, {2, 2}};
        migraphx::shape s1{migraphx::shape::int32_type, {2, 3}};
        migraphx::shape s2{migraphx::shape::int32_type, {2, 1}};
97
98
99
100
        auto l0 = mm->add_literal(migraphx::literal{s0, data0});
        auto l1 = mm->add_literal(migraphx::literal{s1, data1});
        auto l2 = mm->add_literal(migraphx::literal{s2, data2});
        mm->add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
101
        p.compile(migraphx::ref::target{});
102
        auto result           = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
103
104
105
106
107
108
109
110
111
112
113
        std::vector<int> gold = {0, 1, 2, 3, 4, 10, 5, 6, 7, 8, 9, 20};
        std::vector<int> results_vector(2 * 6);
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(results_vector, gold));
        EXPECT(migraphx::verify_range(result.get_shape().lens(), std::vector<std::size_t>({2, 6})));
        EXPECT(
            migraphx::verify_range(result.get_shape().strides(), std::vector<std::size_t>({6, 1})));
    }

    {
        migraphx::program p;
114
        auto* mm               = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
115
116
117
118
119
120
121
        int axis               = 0;
        std::vector<int> data0 = {0, 1, 2, 3};
        std::vector<int> data1 = {4, 5, 6, 7, 8, 9};
        std::vector<int> data2 = {10, 11};
        migraphx::shape s0{migraphx::shape::int32_type, {2, 2}};
        migraphx::shape s1{migraphx::shape::int32_type, {3, 2}};
        migraphx::shape s2{migraphx::shape::int32_type, {1, 2}};
122
123
124
125
        auto l0 = mm->add_literal(migraphx::literal{s0, data0});
        auto l1 = mm->add_literal(migraphx::literal{s1, data1});
        auto l2 = mm->add_literal(migraphx::literal{s2, data2});
        mm->add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
126
        p.compile(migraphx::ref::target{});
127
        auto result           = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
128
129
130
131
132
133
134
135
136
        std::vector<int> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
        std::vector<int> results_vector(6 * 2);
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(results_vector, gold));
        EXPECT(migraphx::verify_range(result.get_shape().lens(), std::vector<std::size_t>({6, 2})));
        EXPECT(
            migraphx::verify_range(result.get_shape().strides(), std::vector<std::size_t>({2, 1})));
    }

Scott Thornton's avatar
Scott Thornton committed
137
    {
Paul's avatar
Paul committed
138
        migraphx::program p;
139
        auto* mm               = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
140
        int axis               = -2;
Scott Thornton's avatar
Scott Thornton committed
141
142
143
        std::vector<int> data0 = {0, 1, 2, 3};
        std::vector<int> data1 = {4, 5, 6, 7, 8, 9};
        std::vector<int> data2 = {10, 11};
Paul's avatar
Paul committed
144
145
146
        migraphx::shape s0{migraphx::shape::int32_type, {2, 2}};
        migraphx::shape s1{migraphx::shape::int32_type, {3, 2}};
        migraphx::shape s2{migraphx::shape::int32_type, {1, 2}};
147
148
149
150
        auto l0 = mm->add_literal(migraphx::literal{s0, data0});
        auto l1 = mm->add_literal(migraphx::literal{s1, data1});
        auto l2 = mm->add_literal(migraphx::literal{s2, data2});
        mm->add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
151
        p.compile(migraphx::ref::target{});
152
        auto result           = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
153
        std::vector<int> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
Scott Thornton's avatar
Scott Thornton committed
154
        std::vector<int> results_vector(6 * 2);
Scott Thornton's avatar
Scott Thornton committed
155
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
156
157
        EXPECT(migraphx::verify_range(results_vector, gold));
        EXPECT(migraphx::verify_range(result.get_shape().lens(), std::vector<std::size_t>({6, 2})));
Scott Thornton's avatar
Scott Thornton committed
158
        EXPECT(
Paul's avatar
Paul committed
159
            migraphx::verify_range(result.get_shape().strides(), std::vector<std::size_t>({2, 1})));
Scott Thornton's avatar
Scott Thornton committed
160
    }
161
162
}

163
164
165
166
TEST_CASE(gather_test)
{
    {
        migraphx::program p;
167
        auto* mm = p.get_main_module();
168
169
170
171

        std::vector<float> data(3 * 3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
172
        auto a0 = mm->add_literal(migraphx::literal{s, data});
173
174
        migraphx::shape s_indices{migraphx::shape::int32_type, {1, 2}};
        std::vector<int> indices{0, 2};
175
        auto a1  = mm->add_literal(migraphx::literal{s_indices, indices});
176
        int axis = 0;
177
        mm->add_instruction(migraphx::op::gather{axis}, a0, a1);
178
        p.compile(migraphx::ref::target{});
179
        auto result = p.eval({}).back();
180
        std::vector<float> res_data(4 * 5);
181
        std::vector<float> golden = {0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
182
183
184
185
        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res_data, golden));
    }

Shucai Xiao's avatar
Shucai Xiao committed
186
187
    {
        migraphx::program p;
188
        auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
189
190
191
192

        std::vector<float> data(3 * 3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
193
        auto a0 = mm->add_literal(migraphx::literal{s, data});
Shucai Xiao's avatar
Shucai Xiao committed
194
195
        migraphx::shape s_indices{migraphx::shape::int32_type, {1, 2}};
        std::vector<int> indices{-3, -1};
196
        auto a1  = mm->add_literal(migraphx::literal{s_indices, indices});
Shucai Xiao's avatar
Shucai Xiao committed
197
        int axis = 0;
198
        mm->add_instruction(migraphx::op::gather{axis}, a0, a1);
199
        p.compile(migraphx::ref::target{});
200
        auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
201
202
203
204
205
206
        std::vector<float> res_data(4 * 5);
        std::vector<float> golden = {0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res_data, golden));
    }

207
208
    {
        migraphx::program p;
209
        auto* mm = p.get_main_module();
210
211
212
213

        std::vector<float> data(3 * 3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
214
        auto a0 = mm->add_literal(migraphx::literal{s, data});
215
216
        migraphx::shape s_indices{migraphx::shape::int32_type, {1, 2}};
        std::vector<int> indices{0, 2};
217
        auto a1  = mm->add_literal(migraphx::literal{s_indices, indices});
218
        int axis = 1;
219
        mm->add_instruction(migraphx::op::gather{axis}, a0, a1);
220
        p.compile(migraphx::ref::target{});
221
        auto result = p.eval({}).back();
222
        std::vector<float> res_data(4 * 5);
223
        std::vector<float> golden = {0.5f, 2.5f, 3.5f, 5.5f, 6.5f, 8.5f};
224
225
226
        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res_data, golden));
    }
227
228
229

    {
        migraphx::program p;
230
        auto* mm = p.get_main_module();
231
232
233
234

        std::vector<float> data(3 * 3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
235
        auto a0 = mm->add_literal(migraphx::literal{s, data});
236
237
        migraphx::shape s_indices{migraphx::shape::int32_type, {1, 2}};
        std::vector<int> indices{0, 2};
238
        auto a1  = mm->add_literal(migraphx::literal{s_indices, indices});
239
        int axis = -1;
240
        mm->add_instruction(migraphx::op::gather{axis}, a0, a1);
241
        p.compile(migraphx::ref::target{});
242
        auto result = p.eval({}).back();
243
        std::vector<float> res_data(4 * 5);
244
        std::vector<float> golden = {0.5f, 2.5f, 3.5f, 5.5f, 6.5f, 8.5f};
245
246
247
        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res_data, golden));
    }
248
249
250

    {
        migraphx::program p;
251
        auto* mm = p.get_main_module();
252
253
254
255

        std::vector<float> data(3 * 3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
256
        auto a0 = mm->add_literal(migraphx::literal{s, data});
257
        // scalar index
258
        migraphx::shape s_indices{migraphx::shape::int32_type};
259
        std::vector<int> indices{0};
260
        auto a1  = mm->add_literal(migraphx::literal{s_indices, indices});
261
        int axis = -1;
262
        mm->add_instruction(migraphx::op::gather{axis}, a0, a1);
263
        p.compile(migraphx::ref::target{});
264
        auto result = p.eval({}).back();
265
266
267
268
269
270
        std::vector<float> res_data{};
        std::vector<float> golden = {0.5f, 3.5f, 6.5f};
        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res_data, golden));
    }

Shucai Xiao's avatar
Shucai Xiao committed
271
272
    {
        migraphx::program p;
273
        auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
274
275
276
277

        std::vector<float> data(3 * 3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
278
        auto a0 = mm->add_literal(migraphx::literal{s, data});
Shucai Xiao's avatar
Shucai Xiao committed
279
280
281
        // scalar index
        migraphx::shape s_indices{migraphx::shape::int32_type};
        std::vector<int> indices{-3};
282
        auto a1  = mm->add_literal(migraphx::literal{s_indices, indices});
Shucai Xiao's avatar
Shucai Xiao committed
283
        int axis = -1;
284
        mm->add_instruction(migraphx::op::gather{axis}, a0, a1);
285
        p.compile(migraphx::ref::target{});
286
        auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
287
288
289
290
291
292
        std::vector<float> res_data{};
        std::vector<float> golden = {0.5f, 3.5f, 6.5f};
        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res_data, golden));
    }

293
294
    {
        migraphx::program p;
295
        auto* mm = p.get_main_module();
296
297
298
299

        std::vector<float> data(3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3}};
300
        auto a0 = mm->add_literal(migraphx::literal{s, data});
301
        // scalar index
302
        migraphx::shape s_indices{migraphx::shape::int32_type};
303
        std::vector<int> indices{0};
304
        auto a1  = mm->add_literal(migraphx::literal{s_indices, indices});
305
        int axis = -1;
306
        mm->add_instruction(migraphx::op::gather{axis}, a0, a1);
307
        p.compile(migraphx::ref::target{});
308
        auto result = p.eval({}).back();
309
310
311
312
313
        std::vector<float> res_data{};
        std::vector<float> golden = {0.5f};
        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res_data, golden));
    }
314
315
}

Paul's avatar
Paul committed
316
TEST_CASE(squeeze_test)
Scott Thornton's avatar
Scott Thornton committed
317
{
318
    {
Paul's avatar
Paul committed
319
        migraphx::program p;
320
        auto* mm = p.get_main_module();
Scott Thornton's avatar
Scott Thornton committed
321
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
322
323
        migraphx::shape s1{migraphx::shape::float_type, {4, 1, 3, 1, 3}};
        migraphx::shape s2{migraphx::shape::float_type, {4, 3, 1, 3}};
324
325
        auto l0 = mm->add_literal(migraphx::literal{s1, data});
        mm->add_instruction(migraphx::op::squeeze{{1}}, l0);
326
        p.compile(migraphx::ref::target{});
327
        auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
328
        EXPECT(result.get_shape() == s2);
329
330
    }
    {
Paul's avatar
Paul committed
331
        migraphx::program p;
332
        auto* mm = p.get_main_module();
Scott Thornton's avatar
Scott Thornton committed
333
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
334
335
        migraphx::shape s1{migraphx::shape::float_type, {4, 1, 3, 1, 3}};
        migraphx::shape s2{migraphx::shape::float_type, {4, 1, 3, 3}};
336
337
        auto l0 = mm->add_literal(migraphx::literal{s1, data});
        mm->add_instruction(migraphx::op::squeeze{{3}}, l0);
338
        p.compile(migraphx::ref::target{});
339
        auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
340
        EXPECT(result.get_shape() == s2);
341
    }
342

343
    {
Paul's avatar
Paul committed
344
        migraphx::program p;
345
        auto* mm = p.get_main_module();
Scott Thornton's avatar
Scott Thornton committed
346
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
347
348
        migraphx::shape s1{migraphx::shape::float_type, {4, 1, 3, 1, 3}};
        migraphx::shape s2{migraphx::shape::float_type, {4, 3, 3}};
349
350
        auto l0 = mm->add_literal(migraphx::literal{s1, data});
        mm->add_instruction(migraphx::op::squeeze{}, l0);
351
        p.compile(migraphx::ref::target{});
352
        auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
353
        EXPECT(result.get_shape() == s2);
354
355
356
    }
}

Paul's avatar
Paul committed
357
TEST_CASE(unsqueeze_test)
Scott Thornton's avatar
Scott Thornton committed
358
{
359
    {
Paul's avatar
Paul committed
360
        migraphx::program p;
361
        auto* mm = p.get_main_module();
Scott Thornton's avatar
Scott Thornton committed
362
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
363
364
        migraphx::shape s1{migraphx::shape::float_type, {4, 3, 3}};
        migraphx::shape s2{migraphx::shape::float_type, {4, 1, 3, 3}};
365
366
        auto l0 = mm->add_literal(migraphx::literal{s1, data});
        mm->add_instruction(migraphx::op::unsqueeze{{1}}, l0);
367
        p.compile(migraphx::ref::target{});
368
        auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
369
370
        EXPECT(result.get_shape() == s2);
    }
371
    {
Paul's avatar
Paul committed
372
        migraphx::program p;
373
        auto* mm = p.get_main_module();
Scott Thornton's avatar
Scott Thornton committed
374
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
375
376
        migraphx::shape s1{migraphx::shape::float_type, {4, 3, 3}};
        migraphx::shape s2{migraphx::shape::float_type, {4, 3, 1, 3}};
377
378
        auto l0 = mm->add_literal(migraphx::literal{s1, data});
        mm->add_instruction(migraphx::op::unsqueeze{{2}}, l0);
379
        p.compile(migraphx::ref::target{});
380
        auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
381
382
        EXPECT(result.get_shape() == s2);
    }
383
384
}

385
386
387
388
389
TEST_CASE(avgpool_test)
{
    // 1D case 1, input is 3D
    {
        migraphx::program p;
390
        auto* mm   = p.get_main_module();
391
392
393
394
395
396
397
        auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
        auto op    = migraphx::op::pooling{"average"};
        op.lengths = {2};
        op.padding = {0};
        op.stride  = {1};

        std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
398
399
        auto l0 = mm->add_literal(migraphx::literal{s, data});
        mm->add_instruction(op, l0);
400
        p.compile(migraphx::ref::target{});
401
402
403
404
405
406
407
408
409
410
411
        auto result = p.eval({}).back();

        std::vector<float> results_vector;
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        std::vector<float> gold{0.25, 0.3, 0.25, 0.65, 0.7, 0.5, 0.4, 0.4, 0.35};
        EXPECT(migraphx::verify_range(results_vector, gold));
    }

    // 1D case 2, stride 2
    {
        migraphx::program p;
412
        auto* mm   = p.get_main_module();
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
        auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 4}};
        auto op    = migraphx::op::pooling{"average"};
        op.lengths = {2};
        op.padding = {1};
        op.stride  = {2};

        std::vector<float> data{1.6321,
                                -2.4186,
                                0.2239,
                                -1.4232,
                                0.8158,
                                0.4103,
                                -0.3149,
                                -0.1361,
                                -0.3442,
                                2.007,
                                0.4331,
                                1.5295,
                                0.9965,
                                0.4766,
                                1.0942,
                                -0.2915};
435
436
        auto l0 = mm->add_literal(migraphx::literal{s, data});
        mm->add_instruction(op, l0);
437
        p.compile(migraphx::ref::target{});
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
        auto result = p.eval({}).back();
        std::vector<float> results_vector;
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        std::vector<float> gold{1.6321,
                                -1.0974,
                                -1.4232,
                                0.8158,
                                0.0477,
                                -0.1361,
                                -0.3442,
                                1.22005,
                                1.5295,
                                0.9965,
                                0.7854,
                                -0.2915};
        EXPECT(migraphx::verify_range(results_vector, gold));
    }

    // 3D, input is 5D
    {
        migraphx::program p;
459
        auto* mm   = p.get_main_module();
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
        auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 3, 3, 3}};
        auto op    = migraphx::op::pooling{"average"};
        op.lengths = {2, 2, 2};
        op.padding = {0, 0, 0};
        op.stride  = {1, 1, 1};

        std::vector<float> data{
            -0.179, -1.756, 0.651,  1.955,  1.87,   -0.604, 0.247,  0.449,  -0.137, 1.187,  1.593,
            0.424,  2.698,  -0.104, -0.069, -1.293, 0.538,  1.291,  0.974,  1.096,  0.74,   -0.669,
            -1.08,  -1.041, -1.407, 1.43,   -0.211, -0.017, 0.532,  1.276,  0.627,  0.236,  -0.396,
            -0.204, 0.501,  -0.599, -1.414, -0.615, -0.274, 0.168,  -0.144, 0.5,    1.42,   1.082,
            -0.952, -0.846, -1.244, 1.475,  1.246,  1.344,  -1.722, -1.24,  -0.851, 0.06,   0.507,
            0.762,  -0.007, -1.484, 1.028,  0.317,  1.077,  -1.289, 0.875,  -0.417, -0.673, 1.715,
            -0.307, 0.264,  -0.973, 1.412,  2.561,  -0.515, -0.201, 0.827,  -1.231, 1.958,  -0.552,
            0.036,  -0.993, -0.859, -1.458, -0.575, 0.048,  -0.779, -1.025, -1.135, 1.166,  -0.131,
            0.726,  0.52,   0.467,  -0.494, 0.675,  0.203,  -0.63,  -0.918, -0.5,   -1.395, 1.39,
            1.705,  0.444,  -0.835, -0.506, 0.101,  0.602,  0.543,  0.357,  1.042};
477
478
        auto l0 = mm->add_literal(migraphx::literal{s, data});
        mm->add_instruction(op, l0);
479
        p.compile(migraphx::ref::target{});
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
        auto result = p.eval({}).back();
        std::vector<float> results_vector;
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        std::vector<float> gold{
            0.908,     0.250625,  0.795,     0.40425, 0.711875,  0.194875,  0.014125,  0.09425,
            -0.078375, 0.139375,  0.46075,   0.0285,  -0.188125, -0.085,    0.378125,  -0.085375,
            -0.04,     0.304125,  0.40775,   0.2835,  0.112375,  -0.073375, 0.4355,    -0.187,
            -0.392625, -0.258375, -0.485875, -0.0345, 0.16125,   -0.131875, -0.228375, 0.068625};
        EXPECT(migraphx::verify_range(results_vector, gold));
    }
}

TEST_CASE(maxpool_test_1D_3D)
{
    // 1D case 1, input is 3D
    {
        migraphx::program p;
497
        auto* mm   = p.get_main_module();
498
499
500
501
502
503
504
        auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
        auto op    = migraphx::op::pooling{"max"};
        op.lengths = {2};
        op.padding = {0};
        op.stride  = {1};

        std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
505
506
        auto l0 = mm->add_literal(migraphx::literal{s, data});
        mm->add_instruction(op, l0);
507
        p.compile(migraphx::ref::target{});
508
509
510
511
512
513
514
515
516
517
518
        auto result = p.eval({}).back();

        std::vector<float> results_vector;
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        std::vector<float> gold{0.3, 0.4, 0.4, 0.8, 0.9, 0.9, 0.7, 0.7, 0.6};
        EXPECT(migraphx::verify_range(results_vector, gold));
    }

    // 1D case 2, input is 3D
    {
        migraphx::program p;
519
        auto* mm   = p.get_main_module();
520
521
522
523
524
525
526
527
528
        auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 5}};
        auto op    = migraphx::op::pooling{"max"};
        op.lengths = {2};
        op.padding = {0};
        op.stride  = {2};

        std::vector<float> data{0.4975, -0.1226, -0.0405, -0.2861, -0.1227, -0.6186, -0.9618,
                                0.6022, -0.1912, 1.1925,  0.5493,  0.1692,  -0.8039, -1.0281,
                                0.9907, 0.477,   1.5001,  -1.1603, -1.361,  1.2556};
529
530
        auto l0 = mm->add_literal(migraphx::literal{s, data});
        mm->add_instruction(op, l0);
531
        p.compile(migraphx::ref::target{});
532
533
534
535
536
537
538
539
        auto result = p.eval({}).back();

        std::vector<float> results_vector;
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        std::vector<float> gold{0.4975, -0.0405, -0.6186, 0.6022, 0.5493, -0.8039, 1.5001, -1.1603};
        EXPECT(migraphx::verify_range(results_vector, gold));
    }

Shucai Xiao's avatar
Shucai Xiao committed
540
541
542
    // 1D case 2, input is 3D, ceil mode
    {
        migraphx::program p;
543
        auto* mm     = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
544
545
546
547
548
549
550
551
552
553
        auto s       = migraphx::shape{migraphx::shape::float_type, {2, 2, 5}};
        auto op      = migraphx::op::pooling{"max"};
        op.lengths   = {2};
        op.padding   = {0};
        op.stride    = {2};
        op.ceil_mode = true;

        std::vector<float> data{0.4975, -0.1226, -0.0405, -0.2861, -0.1227, -0.6186, -0.9618,
                                0.6022, -0.1912, 1.1925,  0.5493,  0.1692,  -0.8039, -1.0281,
                                0.9907, 0.477,   1.5001,  -1.1603, -1.361,  1.2556};
554
555
        auto l0 = mm->add_literal(migraphx::literal{s, data});
        mm->add_instruction(op, l0);
556
        p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
        auto result = p.eval({}).back();

        std::vector<float> results_vector;
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        std::vector<float> gold{0.4975,
                                -0.0405,
                                -0.1227,
                                -0.6186,
                                0.6022,
                                1.1925,
                                0.5493,
                                -0.8039,
                                0.9907,
                                1.5001,
                                -1.1603,
                                1.2556};
        EXPECT(migraphx::verify_range(results_vector, gold));
    }

576
577
578
    // 3D, input is 5D
    {
        migraphx::program p;
579
        auto* mm   = p.get_main_module();
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
        auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 3, 3, 3}};
        auto op    = migraphx::op::pooling{"max"};
        op.lengths = {2, 2, 2};
        op.padding = {0, 0, 0};
        op.stride  = {2, 2, 2};

        std::vector<float> data{
            -2.8029, 0.5861,  0.7015,  0.1297,  -1.44,   -1.9472, 0.7812,  2.408,   -0.3145,
            0.3405,  -0.9146, 0.0624,  1.5064,  -0.8345, 1.7977,  1.8949,  1.0073,  -0.2102,
            -0.042,  -0.7146, 0.6227,  -0.5263, -2.2598, 0.1713,  0.449,   0.5303,  -0.8622,
            -0.5691, 0.907,   -0.0569, -1.5348, -0.4109, -0.1461, -0.5445, 0.4266,  0.2282,
            1.3655,  -2.1519, 0.6068,  -0.2001, -0.4702, 0.3864,  1.7083,  0.9096,  0.4286,
            -1.8866, 0.7034,  0.0293,  1.4587,  0.7672,  -2.8614, 0.8124,  -0.053,  1.0449,
            0.845,   -0.0131, 0.1139,  -0.859,  -1.2681, -0.6337, -0.4644, 0.1938,  0.2889,
            0.9035,  0.7118,  -0.5767, 0.4577,  -0.0549, 0.2237,  0.5756,  0.0677,  -0.0223,
            -0.329,  0.2364,  2.7666,  -0.7417, -1.3196, -0.2655, 0.1698,  -0.1777, -0.9427,
            2.6859,  -0.7501, 0.5175,  1.0029,  -2.6436, -0.4388, -1.2348, -0.1539, -0.6229,
            -0.4136, 0.5085,  0.4136,  -0.6439, -1.1953, -0.406,  -0.0195, 0.1869,  -0.8664,
            1.1364,  0.5041,  0.0647,  0.1941,  -1.0819, -0.4629, -0.5107, 0.3612,  -0.3583};
599
600
        auto l0 = mm->add_literal(migraphx::literal{s, data});
        mm->add_instruction(op, l0);
601
        p.compile(migraphx::ref::target{});
602
603
604
605
606
607
608
609
        auto result = p.eval({}).back();
        std::vector<float> results_vector;
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        std::vector<float> gold{1.5064, 1.3655, 0.9035, 2.6859};
        EXPECT(migraphx::verify_range(results_vector, gold));
    }
}

Paul's avatar
Paul committed
610
TEST_CASE(globalavgpool_test)
611
{
Paul's avatar
Paul committed
612
    migraphx::program p;
613
    auto* mm   = p.get_main_module();
Paul's avatar
Paul committed
614
615
    auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}};
    auto op    = migraphx::op::pooling{"average"};
616
    auto lens  = s.lens();
Khalique's avatar
Khalique committed
617
    op.lengths = {lens[2], lens[3]};
618
619

    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
620
621
    auto l0 = mm->add_literal(migraphx::literal{s, data});
    mm->add_instruction(op, l0);
622
    p.compile(migraphx::ref::target{});
623
    auto result = p.eval({}).back();
624
625
626
627

    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{0.25, 0.575, 0.375};
Paul's avatar
Paul committed
628
    EXPECT(migraphx::verify_range(results_vector, gold));
629
630
}

Paul's avatar
Paul committed
631
TEST_CASE(globalmaxpool_test)
632
{
Paul's avatar
Paul committed
633
    migraphx::program p;
634
    auto* mm   = p.get_main_module();
Paul's avatar
Paul committed
635
636
    auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}};
    auto op    = migraphx::op::pooling{"max"};
637
    auto lens  = s.lens();
Khalique's avatar
Khalique committed
638
    op.lengths = {lens[2], lens[3]};
639
640

    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
641
642
    auto l0 = mm->add_literal(migraphx::literal{s, data});
    mm->add_instruction(op, l0);
643
    p.compile(migraphx::ref::target{});
644
    auto result = p.eval({}).back();
645
646
647
648

    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{0.4, 0.9, 0.7};
Paul's avatar
Paul committed
649
    EXPECT(migraphx::verify_range(results_vector, gold));
650
651
}

Paul's avatar
Paul committed
652
TEST_CASE(im2col_3x3_no_pad_identity_test)
Scott Thornton's avatar
Scott Thornton committed
653
654
655
{
    std::size_t f[2]    = {3, 3};
    std::size_t size[2] = {3, 3};
656
657
658
    std::vector<std::size_t> padding{0, 0};
    std::vector<std::size_t> stride{1, 1};
    std::vector<std::size_t> dilation{1, 1};
Scott Thornton's avatar
Scott Thornton committed
659
660
661
662
663
664
    std::size_t channels = 1;

    std::vector<int32_t> weights(channels * f[0] * f[1]);
    std::vector<int32_t> input(channels * size[0] * size[1]);
    std::iota(input.begin(), input.end(), 0);

Paul's avatar
Paul committed
665
    migraphx::program p;
666
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
667
668
    migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
    migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
669
670
671
    auto l_image   = mm->add_literal(migraphx::literal{s_image, input});
    auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
    mm->add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
672
    p.compile(migraphx::ref::target{});
673
    auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
674
675
676
677
678

    std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
    std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
    std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
679
    EXPECT(migraphx::verify_range(results_vector, input));
Scott Thornton's avatar
Scott Thornton committed
680
681
}

Paul's avatar
Paul committed
682
TEST_CASE(im2col_3x3_no_pad_test)
Scott Thornton's avatar
Scott Thornton committed
683
684
685
{
    std::size_t f[2]    = {3, 3};
    std::size_t size[2] = {4, 4};
686
687
688
    std::vector<std::size_t> padding{0, 0};
    std::vector<std::size_t> stride{1, 1};
    std::vector<std::size_t> dilation{1, 1};
Scott Thornton's avatar
Scott Thornton committed
689
690
691
692
693
694
    std::size_t channels = 1;

    std::vector<int32_t> weights(channels * f[0] * f[1]);
    std::vector<int32_t> input(channels * size[0] * size[1]);
    std::iota(input.begin(), input.end(), 0);

Paul's avatar
Paul committed
695
    migraphx::program p;
696
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
697
698
    migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
    migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
699
700
701
    auto l_image   = mm->add_literal(migraphx::literal{s_image, input});
    auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
    mm->add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
702
    p.compile(migraphx::ref::target{});
703
    auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
704
705
706
707
708
709
710
711

    std::vector<int> correct = {0, 1, 2, 4, 5, 6,  8,  9,  10, 1, 2, 3, 5, 6,  7,  9,  10, 11,
                                4, 5, 6, 8, 9, 10, 12, 13, 14, 5, 6, 7, 9, 10, 11, 13, 14, 15};

    std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
    std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
    std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
712
    EXPECT(migraphx::verify_range(results_vector, correct));
Scott Thornton's avatar
Scott Thornton committed
713
714
}

Paul's avatar
Paul committed
715
TEST_CASE(im2col_3x3_stride_2_no_pad_test)
Scott Thornton's avatar
Scott Thornton committed
716
717
718
{
    std::size_t f[2]    = {3, 3};
    std::size_t size[2] = {6, 6};
719
720
721
    std::vector<std::size_t> padding{0, 0};
    std::vector<std::size_t> stride{2, 2};
    std::vector<std::size_t> dilation{1, 1};
Scott Thornton's avatar
Scott Thornton committed
722
723
724
725
726
727
    std::size_t channels = 1;

    std::vector<int32_t> weights(channels * f[0] * f[1]);
    std::vector<int32_t> input(channels * size[0] * size[1]);
    std::iota(input.begin(), input.end(), 0);

Paul's avatar
Paul committed
728
    migraphx::program p;
729
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
730
731
    migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
    migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
732
733
734
    auto l_image   = mm->add_literal(migraphx::literal{s_image, input});
    auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
    mm->add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
735
    p.compile(migraphx::ref::target{});
736
    auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
737
738
739
740
741
742
743
744
745

    std::vector<int> correct = {0,  1,  2,  6,  7,  8,  12, 13, 14, 2,  3,  4,
                                8,  9,  10, 14, 15, 16, 12, 13, 14, 18, 19, 20,
                                24, 25, 26, 14, 15, 16, 20, 21, 22, 26, 27, 28};

    std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
    std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
    std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
746
    EXPECT(migraphx::verify_range(results_vector, correct));
Scott Thornton's avatar
Scott Thornton committed
747
748
}

Paul's avatar
Paul committed
749
TEST_CASE(im2col_3x3_with_padding_test)
Scott Thornton's avatar
Scott Thornton committed
750
751
752
{
    std::size_t f[2]    = {3, 3};
    std::size_t size[2] = {2, 2};
753
754
755
    std::vector<std::size_t> padding{1, 1};
    std::vector<std::size_t> stride{1, 1};
    std::vector<std::size_t> dilation{1, 1};
Scott Thornton's avatar
Scott Thornton committed
756
757
758
759
760
761
    std::size_t channels = 1;

    std::vector<int32_t> weights(channels * f[0] * f[1]);
    std::vector<int32_t> input(channels * size[0] * size[1]);
    std::iota(input.begin(), input.end(), 0);

Paul's avatar
Paul committed
762
    migraphx::program p;
763
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
764
765
    migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
    migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
766
767
768
    auto l_image   = mm->add_literal(migraphx::literal{s_image, input});
    auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
    mm->add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
769
    p.compile(migraphx::ref::target{});
770
    auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
771
772
773
774
775
776
777
778

    std::vector<int> correct = {0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0,
                                0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0};

    std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
    std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
    std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
779
    EXPECT(migraphx::verify_range(results_vector, correct));
Scott Thornton's avatar
Scott Thornton committed
780
781
}

Shucai Xiao's avatar
Shucai Xiao committed
782
783
784
TEST_CASE(batch_norm_1d_test)
{
    migraphx::program p;
785
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
786
787
788
789
790
791
792
793
794
795
796
797
    migraphx::shape x_shape{migraphx::shape::float_type, {2, 3, 4}};
    migraphx::shape c_shape(migraphx::shape::float_type, {3});

    std::vector<float> x_data        = {0.7253,  -0.6356, 0.4606,  -0.8689, -1.1932, 0.4538,
                                 -1.0018, -0.365,  -0.214,  -0.9553, -0.7672, 0.2331,
                                 -0.8416, -0.6142, 0.0814,  0.2498,  -0.6706, 1.4872,
                                 0.5112,  -1.5212, -0.9126, 0.0735,  1.085,   -0.3417};
    std::vector<float> scale_data    = {1.1, 1.2, 1.3};
    std::vector<float> bias_data     = {0.1, 0.2, 0.3};
    std::vector<float> mean_data     = {-0.1804, -0.2875, -0.2249};
    std::vector<float> variance_data = {2.7914, 7.3424, 3.3287};

798
799
800
801
802
    auto x        = mm->add_literal(migraphx::literal{x_shape, x_data});
    auto scale    = mm->add_literal(migraphx::literal{c_shape, scale_data});
    auto bias     = mm->add_literal(migraphx::literal{c_shape, bias_data});
    auto mean     = mm->add_literal(migraphx::literal{c_shape, mean_data});
    auto variance = mm->add_literal(migraphx::literal{c_shape, variance_data});
Shucai Xiao's avatar
Shucai Xiao committed
803

804
    mm->add_instruction(migraphx::op::batch_norm_inference{1e-5}, x, scale, bias, mean, variance);
805
    p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
806
807
808
809
810
811
812
813
814
815
816
817
818
819
    auto result = p.eval({}).back();

    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0.696301,  -0.199697, 0.522026,  -0.353299, -0.201094, 0.528289,
                               -0.116332, 0.165679,  0.307767,  -0.220435, -0.086407, 0.62634,
                               -0.335325, -0.185608, 0.272366,  0.383238,  0.0303421, 0.985936,
                               0.553709,  -0.346351, -0.190009, 0.51262,   1.23335,   0.216776};
    EXPECT(migraphx::verify_range(result_vector, gold));
}

TEST_CASE(batch_norm_1d_per_actv_test)
{
    migraphx::program p;
820
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
    migraphx::shape x_shape{migraphx::shape::float_type, {2, 2, 4}};
    migraphx::shape c_shape(migraphx::shape::float_type, {2, 4});

    std::vector<float> x_data     = {0.3547,
                                 0.477,
                                 -1.8575,
                                 0.663,
                                 -0.1881,
                                 -0.5113,
                                 -0.1803,
                                 -0.5915,
                                 -0.1552,
                                 0.9821,
                                 1.827,
                                 0.0558,
                                 -0.0417,
                                 -1.0693,
                                 1.9948,
                                 -0.7448};
    std::vector<float> scale_data = {
        -0.3181, -0.3885, 1.655, 0.0704, -0.2565, -1.1761, -0.3751, 0.1057};
    std::vector<float> bias_data = {
        -1.2118, -2.1156, 0.0046, -0.1341, -0.2724, -1.0718, 0.5535, -0.889};
    std::vector<float> mean_data = {
        0.0997, 0.7295, -0.0153, 0.3594, -0.1149, -0.7903, 0.9073, -0.6681};
    std::vector<float> variance_data = {
        0.13, 0.1276, 6.7878, 0.1843, 0.0107, 0.1556, 2.3655, 0.0117};

849
850
851
852
853
    auto x        = mm->add_literal(migraphx::literal{x_shape, x_data});
    auto scale    = mm->add_literal(migraphx::literal{c_shape, scale_data});
    auto bias     = mm->add_literal(migraphx::literal{c_shape, bias_data});
    auto mean     = mm->add_literal(migraphx::literal{c_shape, mean_data});
    auto variance = mm->add_literal(migraphx::literal{c_shape, variance_data});
Shucai Xiao's avatar
Shucai Xiao committed
854

855
    mm->add_instruction(
Shucai Xiao's avatar
Shucai Xiao committed
856
857
858
859
860
861
862
        migraphx::op::batch_norm_inference{
            1e-6, 0.9, migraphx::op::batch_norm_inference::per_activation},
        x,
        scale,
        bias,
        mean,
        variance);
863
    p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
    auto result = p.eval({}).back();

    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-1.43677,
                               -1.84098,
                               -1.16563,
                               -0.0843136,
                               -0.090896,
                               -1.90364,
                               0.81875,
                               -0.81415,
                               -0.986915,
                               -2.39032,
                               1.17489,
                               -0.183886,
                               -0.453904,
                               -0.239955,
                               0.288275,
                               -0.963948};
    EXPECT(migraphx::verify_range(result_vector, gold));
}

Paul's avatar
Paul committed
887
TEST_CASE(batch_norm_inference_test)
888
{
Paul's avatar
Paul committed
889
    migraphx::program p;
890
    auto* mm                 = p.get_main_module();
Paul's avatar
Paul committed
891
892
893
894
895
896
    const size_t width       = 2;
    const size_t height      = 2;
    const size_t channels    = 4;
    const size_t batches     = 2;
    const float x_val        = 8.0;
    const float mean_val     = 2.0;
Paul's avatar
Paul committed
897
    const float variance_val = 4.0;
Paul's avatar
Paul committed
898
899
    const float scale_val    = 2.0f;
    const float bias_val     = 1.0f;
Aditya Atluri's avatar
Aditya Atluri committed
900
901
    const float output_val = scale_val * (x_val - mean_val) / (std::sqrt(variance_val)) + bias_val;

Paul's avatar
Paul committed
902
903
    migraphx::shape s{migraphx::shape::float_type, {batches, channels, height, width}};
    migraphx::shape vars{migraphx::shape::float_type, {channels}};
Aditya Atluri's avatar
Aditya Atluri committed
904
905
906
907
908
909
910
911
912
913
914
915
    std::vector<float> x_data(width * height * channels * batches);
    std::vector<float> scale_data(channels);
    std::vector<float> bias_data(channels);
    std::vector<float> mean_data(channels);
    std::vector<float> variance_data(channels);

    std::fill(x_data.begin(), x_data.end(), x_val);
    std::fill(mean_data.begin(), mean_data.end(), mean_val);
    std::fill(variance_data.begin(), variance_data.end(), variance_val);
    std::fill(scale_data.begin(), scale_data.end(), scale_val);
    std::fill(bias_data.begin(), bias_data.end(), bias_val);

916
917
918
919
920
    auto x        = mm->add_literal(migraphx::literal{s, x_data});
    auto scale    = mm->add_literal(migraphx::literal{vars, scale_data});
    auto bias     = mm->add_literal(migraphx::literal{vars, bias_data});
    auto mean     = mm->add_literal(migraphx::literal{vars, mean_data});
    auto variance = mm->add_literal(migraphx::literal{vars, variance_data});
Aditya Atluri's avatar
Aditya Atluri committed
921

922
    mm->add_instruction(migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
923
    p.compile(migraphx::ref::target{});
924
    auto result = p.eval({}).back();
Aditya Atluri's avatar
Aditya Atluri committed
925
926
927
928

    std::vector<float> result_vector(width * height * channels * batches);
    std::vector<float> gold(width * height * channels * batches);
    std::fill(gold.begin(), gold.end(), output_val);
Aditya Atluri's avatar
Aditya Atluri committed
929
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
Aditya Atluri's avatar
Aditya Atluri committed
930

Paul's avatar
Paul committed
931
    EXPECT(migraphx::verify_range(result_vector, gold));
932
933
}

Shucai Xiao's avatar
Shucai Xiao committed
934
935
936
TEST_CASE(batch_norm_3d_test)
{
    migraphx::program p;
937
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
938
939
940
941
942
943
944
945
946
947
948
949
950
    migraphx::shape x_shape{migraphx::shape::float_type, {2, 2, 2, 2, 2}};
    migraphx::shape c_shape(migraphx::shape::float_type, {2});

    std::vector<float> x_data     = {-1.0833, 1.9681,  1.2075,  -0.723,  -0.4076, -0.8738, 0.5853,
                                 -0.5357, 1.734,   0.7904,  0.6953,  -0.468,  -0.425,  0.6895,
                                 0.0096,  0.4205,  -0.1749, 1.2821,  2.1453,  -0.8538, 1.0687,
                                 0.0906,  0.0714,  -1.3079, -0.6376, 1.3023,  0.945,   0.0927,
                                 -0.7421, -1.4341, -1.0309, 1.5153};
    std::vector<float> scale_data = {1.1, 1.3};
    std::vector<float> bias_data  = {0.1, 0.2};
    std::vector<float> mean_data  = {0.1537, 0.2161};
    std::vector<float> variance_data = {18.0805, 13.3906};

951
952
953
954
955
    auto x        = mm->add_literal(migraphx::literal{x_shape, x_data});
    auto scale    = mm->add_literal(migraphx::literal{c_shape, scale_data});
    auto bias     = mm->add_literal(migraphx::literal{c_shape, bias_data});
    auto mean     = mm->add_literal(migraphx::literal{c_shape, mean_data});
    auto variance = mm->add_literal(migraphx::literal{c_shape, variance_data});
Shucai Xiao's avatar
Shucai Xiao committed
956

957
    mm->add_instruction(migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
958
    p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
959
960
961
962
963
964
965
966
967
968
969
    auto result = p.eval({}).back();
    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {
        -0.220005, 0.569376, 0.372612, -0.126798,  -0.0452053, -0.165809, 0.211653,  -0.0783441,
        0.739245,  0.404024, 0.370239, -0.0430317, -0.0277556, 0.368179,  0.126639,  0.272615,
        0.0149929, 0.391911, 0.615216, -0.160635,  0.336706,   0.0836764, 0.0787094, -0.278108,
        -0.103283, 0.585881, 0.458947, 0.156161,   -0.140408,  -0.386246, -0.243006, 0.661551};
    EXPECT(migraphx::verify_range(result_vector, gold));
}

Paul's avatar
Paul committed
970
TEST_CASE(im2col_3x3_with_channels_identity_test)
Scott Thornton's avatar
Scott Thornton committed
971
972
973
{
    std::size_t f[2]    = {3, 3};
    std::size_t size[2] = {3, 3};
974
975
976
    std::vector<std::size_t> padding{0, 0};
    std::vector<std::size_t> stride{1, 1};
    std::vector<std::size_t> dilation{1, 1};
Scott Thornton's avatar
Scott Thornton committed
977
978
979
980
981
982
    std::size_t channels = 2;

    std::vector<int32_t> weights(channels * f[0] * f[1]);
    std::vector<int32_t> input(channels * size[0] * size[1]);
    std::iota(input.begin(), input.end(), 0);

Paul's avatar
Paul committed
983
    migraphx::program p;
984
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
985
986
    migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
    migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
987
988
989
    auto l_image   = mm->add_literal(migraphx::literal{s_image, input});
    auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
    mm->add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
990
    p.compile(migraphx::ref::target{});
991
    auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
992
993
994
995
996

    std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
    std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
    std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
997
    EXPECT(migraphx::verify_range(results_vector, input));
Scott Thornton's avatar
Scott Thornton committed
998
999
}

Paul's avatar
Paul committed
1000
TEST_CASE(exp_test)
1001
{
Paul's avatar
Paul committed
1002
    migraphx::program p;
1003
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1004
    migraphx::shape s{migraphx::shape::float_type, {3}};
1005
1006
    auto l = mm->add_literal(migraphx::literal{s, {-1, 0, 1}});
    mm->add_instruction(migraphx::op::exp{}, l);
1007
    p.compile(migraphx::ref::target{});
1008
    auto result = p.eval({}).back();
1009
    std::vector<float> results_vector(3);
1010
1011
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0.36787944f, 1.f, 2.71828183f};
Paul's avatar
Paul committed
1012
    EXPECT(migraphx::verify_range(results_vector, gold));
1013
1014
}

Shucai Xiao's avatar
Shucai Xiao committed
1015
1016
1017
TEST_CASE(erf_test)
{
    migraphx::program p;
1018
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1019
    migraphx::shape s{migraphx::shape::float_type, {4}};
Shucai Xiao's avatar
Shucai Xiao committed
1020
    auto l =
1021
1022
        mm->add_literal(migraphx::literal{s, {0.73785057, 1.58165966, -0.43597795, -0.01677432}});
    mm->add_instruction(migraphx::op::erf{}, l);
1023
    p.compile(migraphx::ref::target{});
1024
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
1025
1026
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Shucai Xiao's avatar
Shucai Xiao committed
1027
    std::vector<float> gold = {0.70327317, 0.97470088, -0.46247893, -0.01892602};
Shucai Xiao's avatar
Shucai Xiao committed
1028
1029
1030
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
1031
1032
1033
TEST_CASE(sqrt_test)
{
    migraphx::program p;
1034
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1035
    migraphx::shape s{migraphx::shape::float_type, {5}};
1036
    auto l = mm->add_literal(
Shucai Xiao's avatar
Shucai Xiao committed
1037
        migraphx::literal{s, {1.02481645, 0.85643062, 0.03404123, 0.92791926, 0.10569184}});
1038
    mm->add_instruction(migraphx::op::sqrt{}, l);
1039
    p.compile(migraphx::ref::target{});
1040
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
1041
1042
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Shucai Xiao's avatar
Shucai Xiao committed
1043
    std::vector<float> gold = {1.01233218, 0.92543537, 0.18450265, 0.96328566, 0.32510282};
Shucai Xiao's avatar
Shucai Xiao committed
1044
1045
1046
    EXPECT(migraphx::verify_range(results_vector, gold));
}

1047
1048
1049
TEST_CASE(sign_test)
{
    migraphx::program p;
1050
    auto* mm = p.get_main_module();
1051
    migraphx::shape s{migraphx::shape::float_type, {5}};
1052
    auto l = mm->add_literal(
1053
        migraphx::literal{s, {1.02481645, 0.85643062, -0.03404123, -0.92791926, 0.0}});
1054
    mm->add_instruction(migraphx::op::sign{}, l);
1055
    p.compile(migraphx::ref::target{});
1056
    auto result = p.eval({}).back();
1057
1058
1059
1060
1061
1062
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {1.0, 1.0, -1.0, -1.0, 0.0};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
1063
1064
1065
TEST_CASE(log_test)
{
    migraphx::program p;
1066
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1067
    migraphx::shape s{migraphx::shape::float_type, {3}};
1068
1069
    auto l = mm->add_literal(migraphx::literal{s, {1, 2, 3}});
    mm->add_instruction(migraphx::op::log{}, l);
1070
    p.compile(migraphx::ref::target{});
1071
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
1072
1073
1074
1075
1076
1077
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0.0f, 0.6931471806f, 1.0986122887f};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
1078
1079
1080
TEST_CASE(prelu_test)
{
    migraphx::program p;
1081
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1082
    migraphx::shape s{migraphx::shape::float_type, {3}};
1083
1084
1085
    auto x     = mm->add_literal(migraphx::literal{s, {-1, 0, 2}});
    auto slope = mm->add_literal(migraphx::literal{s, {2, 1, 2}});
    mm->add_instruction(migraphx::op::prelu{}, x, slope);
1086
    p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
1087
1088
1089
1090
1091
1092
1093
    auto result = p.eval({}).back();
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-2.0f, 0.0f, 2.0f};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
1094
1095
1096
TEST_CASE(pow_test)
{
    migraphx::program p;
1097
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1098
    migraphx::shape s{migraphx::shape::float_type, {3}};
1099
1100
1101
    auto b = mm->add_literal(migraphx::literal{s, {1, 2, 3}});
    auto e = mm->add_literal(migraphx::literal{s, {1, 2, 3}});
    mm->add_instruction(migraphx::op::pow{}, b, e);
1102
    p.compile(migraphx::ref::target{});
1103
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
1104
1105
1106
1107
1108
1109
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {1.0f, 4.0f, 27.0f};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Paul's avatar
Paul committed
1110
TEST_CASE(sin_test)
1111
{
Paul's avatar
Paul committed
1112
    migraphx::program p;
1113
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1114
    migraphx::shape s{migraphx::shape::float_type, {3}};
1115
1116
    auto l = mm->add_literal(migraphx::literal{s, {-1, 0, 1}});
    mm->add_instruction(migraphx::op::sin{}, l);
1117
    p.compile(migraphx::ref::target{});
1118
    auto result = p.eval({}).back();
1119
    std::vector<float> results_vector(3);
1120
1121
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-0.84147098f, 0.f, 0.84147098f};
Paul's avatar
Paul committed
1122
    EXPECT(migraphx::verify_range(results_vector, gold));
1123
1124
}

Paul's avatar
Paul committed
1125
TEST_CASE(cos_test)
1126
{
Paul's avatar
Paul committed
1127
    migraphx::program p;
1128
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1129
    migraphx::shape s{migraphx::shape::float_type, {3}};
1130
1131
    auto l = mm->add_literal(migraphx::literal{s, {-1, 0, 1}});
    mm->add_instruction(migraphx::op::cos{}, l);
1132
    p.compile(migraphx::ref::target{});
1133
    auto result = p.eval({}).back();
1134
    std::vector<float> results_vector(3);
1135
1136
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0.54030231f, 1.f, 0.54030231f};
Paul's avatar
Paul committed
1137
    EXPECT(migraphx::verify_range(results_vector, gold));
1138
1139
}

Paul's avatar
Paul committed
1140
TEST_CASE(tan_test)
1141
{
Paul's avatar
Paul committed
1142
    migraphx::program p;
1143
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1144
    migraphx::shape s{migraphx::shape::float_type, {3}};
1145
1146
    auto l = mm->add_literal(migraphx::literal{s, {-1, 0, 1}});
    mm->add_instruction(migraphx::op::tan{}, l);
1147
    p.compile(migraphx::ref::target{});
1148
    auto result = p.eval({}).back();
1149
    std::vector<float> results_vector(3);
1150
1151
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-1.55740772f, 0.0f, 1.55740772f};
Paul's avatar
Paul committed
1152
    EXPECT(migraphx::verify_range(results_vector, gold));
1153
1154
}

1155
1156
1157
TEST_CASE(asin_test)
{
    migraphx::program p;
1158
    auto* mm = p.get_main_module();
1159
1160
    migraphx::shape s{migraphx::shape::float_type, {3}};
    std::vector<float> data{-0.5f, 0.0f, 0.9f};
1161
1162
    auto l = mm->add_literal(migraphx::literal{s, data});
    mm->add_instruction(migraphx::op::asin{}, l);
1163
    p.compile(migraphx::ref::target{});
1164
    auto result = p.eval({}).back();
1165
1166
1167
1168
1169
1170
1171
1172
1173
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-0.5235987756f, 0.f, 1.119769515};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(acos_test)
{
    migraphx::program p;
1174
    auto* mm = p.get_main_module();
1175
1176
    migraphx::shape s{migraphx::shape::double_type, {3}};
    std::vector<float> data{-0.8f, 0.0f, 1.0f};
1177
1178
    auto l = mm->add_literal(migraphx::literal{s, data});
    mm->add_instruction(migraphx::op::acos{}, l);
1179
    p.compile(migraphx::ref::target{});
1180
    auto result = p.eval({}).back();
1181
1182
1183
1184
1185
1186
1187
1188
1189
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {2.4980915448f, 1.5707963268f, 0.0f};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(atan_test)
{
    migraphx::program p;
1190
    auto* mm = p.get_main_module();
1191
    migraphx::shape s{migraphx::shape::double_type, {3}};
1192
1193
    auto l = mm->add_literal(migraphx::literal{s, {-1, 0, 1}});
    mm->add_instruction(migraphx::op::atan{}, l);
1194
    p.compile(migraphx::ref::target{});
1195
    auto result = p.eval({}).back();
1196
1197
1198
1199
1200
1201
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-0.7853981634f, 0.0f, 0.7853981634f};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

1202
1203
1204
TEST_CASE(asinh_test)
{
    migraphx::program p;
1205
    auto* mm = p.get_main_module();
1206
1207
    migraphx::shape s{migraphx::shape::float_type, {3}};
    std::vector<float> data{-0.5f, 0.0f, 0.9f};
1208
1209
    auto l = mm->add_literal(migraphx::literal{s, data});
    mm->add_instruction(migraphx::op::asinh{}, l);
1210
    p.compile(migraphx::ref::target{});
1211
    auto result = p.eval({}).back();
1212
1213
1214
1215
1216
1217
1218
1219
1220
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-0.481211841, 0, 0.808866858};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(acosh_test)
{
    migraphx::program p;
1221
    auto* mm = p.get_main_module();
1222
1223
    migraphx::shape s{migraphx::shape::double_type, {3}};
    std::vector<float> data{1.1f, 1.2f, 2.0f};
1224
1225
    auto l = mm->add_literal(migraphx::literal{s, data});
    mm->add_instruction(migraphx::op::acosh{}, l);
1226
    p.compile(migraphx::ref::target{});
1227
    auto result = p.eval({}).back();
1228
1229
1230
1231
1232
1233
1234
1235
1236
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0.4435683, 0.6223626, 1.316958};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(atanh_test)
{
    migraphx::program p;
1237
    auto* mm = p.get_main_module();
1238
    migraphx::shape s{migraphx::shape::double_type, {3}};
1239
1240
    auto l = mm->add_literal(migraphx::literal{s, {0.4435683, 0.6223626, 0.316958}});
    mm->add_instruction(migraphx::op::atanh{}, l);
1241
    p.compile(migraphx::ref::target{});
1242
    auto result = p.eval({}).back();
1243
1244
1245
1246
1247
1248
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0.476664424, 0.728852153, 0.328261733};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Paul's avatar
Paul committed
1249
TEST_CASE(add_test)
1250
{
Paul's avatar
Paul committed
1251
    migraphx::program p;
1252
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1253
    migraphx::shape s{migraphx::shape::float_type, {3}};
1254
1255
1256
    auto l1 = mm->add_literal(migraphx::literal{s, {-1, 0, 1}});
    auto l2 = mm->add_literal(migraphx::literal{s, {1, 2, 3}});
    mm->add_instruction(migraphx::op::add{}, l1, l2);
1257
    p.compile(migraphx::ref::target{});
1258
    auto result = p.eval({}).back();
1259
1260
1261
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0, 2, 4};
Paul's avatar
Paul committed
1262
    EXPECT(migraphx::verify_range(results_vector, gold));
1263
1264
}

Paul's avatar
Paul committed
1265
TEST_CASE(broadcast_test)
1266
{
Paul's avatar
Paul committed
1267
    migraphx::program p;
1268
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1269
    migraphx::shape a_shape{migraphx::shape::int32_type, {2, 2}};
1270
    std::vector<int32_t> a_data{0, 0, 0, 0};
Paul's avatar
Paul committed
1271
    migraphx::shape b_shape{migraphx::shape::int32_type, {2}};
1272
    std::vector<int32_t> b_data{-2, -3};
1273
    uint64_t axis = 0;
1274
1275
1276
    auto l1       = mm->add_literal(migraphx::literal{a_shape, a_data});
    auto l2       = mm->add_literal(migraphx::literal{b_shape, b_data});
    mm->add_instruction(migraphx::op::broadcast{axis, l1->get_shape().lens()}, l2);
1277
    p.compile(migraphx::ref::target{});
1278
    auto result = p.eval({}).back();
Paul's avatar
Paul committed
1279
    auto output = result.get<int32_t>();
Paul's avatar
Paul committed
1280
1281
1282
1283
    EXPECT(output(0, 0) == -2);
    EXPECT(output(0, 1) == -2);
    EXPECT(output(1, 0) == -3);
    EXPECT(output(1, 1) == -3);
1284
}
Paul's avatar
Paul committed
1285
TEST_CASE(add_broadcast_test)
1286
{
1287
    {
Paul's avatar
Paul committed
1288
        migraphx::program p;
1289
        auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1290
        migraphx::shape a_shape{migraphx::shape::float_type, {2, 2, 3}};
1291
        std::vector<float> a_data{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
Paul's avatar
Paul committed
1292
        migraphx::shape b_shape{migraphx::shape::float_type, {2, 2}};
1293
1294
        std::vector<float> b_data{0, -1, -2, -3};
        uint64_t axis = 0;
1295
1296
1297
1298
        auto l1       = mm->add_literal(migraphx::literal{a_shape, a_data});
        auto l2       = mm->add_literal(migraphx::literal{b_shape, b_data});
        auto l3 = mm->add_instruction(migraphx::op::broadcast{axis, l1->get_shape().lens()}, l2);
        mm->add_instruction(migraphx::op::add{}, l1, l3);
1299
        p.compile(migraphx::ref::target{});
1300
        auto result = p.eval({}).back();
1301
1302
1303
1304
        EXPECT(result.get_shape().packed());
        std::vector<float> results_vector(12);
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        std::vector<float> gold = {0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8};
Paul's avatar
Paul committed
1305
        EXPECT(migraphx::verify_range(results_vector, gold));
1306
1307
    }
    {
Paul's avatar
Paul committed
1308
        migraphx::program p;
1309
        auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1310
        migraphx::shape a_shape{migraphx::shape::float_type, {2, 2, 3}};
1311
        std::vector<float> a_data{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
Paul's avatar
Paul committed
1312
        migraphx::shape b_shape{migraphx::shape::float_type, {2, 2, 1}};
1313
        std::vector<float> b_data{0, -1, -2, -3};
1314
1315
1316
1317
1318
        auto l1 = mm->add_literal(migraphx::literal{a_shape, a_data});
        auto l2 = mm->add_literal(migraphx::literal{b_shape, b_data});
        auto l3 = mm->add_instruction(migraphx::op::multibroadcast{{2, 2, 3}}, l1);
        auto l4 = mm->add_instruction(migraphx::op::multibroadcast{{2, 2, 3}}, l2);
        mm->add_instruction(migraphx::op::add{}, l3, l4);
1319
        p.compile(migraphx::ref::target{});
1320
        auto result = p.eval({}).back();
1321
1322
1323
1324
        EXPECT(result.get_shape().packed());
        std::vector<float> results_vector(12);
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        std::vector<float> gold = {0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8};
Paul's avatar
Paul committed
1325
        EXPECT(migraphx::verify_range(results_vector, gold));
1326
    }
1327
1328
}

Paul's avatar
Paul committed
1329
TEST_CASE(sub_test)
1330
{
Paul's avatar
Paul committed
1331
    migraphx::program p;
1332
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1333
    migraphx::shape s{migraphx::shape::float_type, {3}};
1334
1335
1336
    auto l1 = mm->add_literal(migraphx::literal{s, {-1, 0, 1}});
    auto l2 = mm->add_literal(migraphx::literal{s, {1, 2, 3}});
    mm->add_instruction(migraphx::op::sub{}, l1, l2);
1337
    p.compile(migraphx::ref::target{});
1338
    auto result = p.eval({}).back();
1339
1340
1341
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-2, -2, -2};
Paul's avatar
Paul committed
1342
    EXPECT(migraphx::verify_range(results_vector, gold));
1343
1344
}

Paul's avatar
Paul committed
1345
TEST_CASE(mul_test)
1346
{
Paul's avatar
Paul committed
1347
    migraphx::program p;
1348
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1349
    migraphx::shape s{migraphx::shape::float_type, {3}};
1350
1351
1352
    auto l1 = mm->add_literal(migraphx::literal{s, {-1, 0, 1}});
    auto l2 = mm->add_literal(migraphx::literal{s, {1, 2, 3}});
    mm->add_instruction(migraphx::op::mul{}, l1, l2);
1353
    p.compile(migraphx::ref::target{});
1354
    auto result = p.eval({}).back();
1355
1356
1357
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-1, 0, 3};
Paul's avatar
Paul committed
1358
    EXPECT(migraphx::verify_range(results_vector, gold));
1359
1360
}

Paul's avatar
Paul committed
1361
TEST_CASE(div_test)
1362
{
Paul's avatar
Paul committed
1363
    migraphx::program p;
1364
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1365
    migraphx::shape s{migraphx::shape::float_type, {3}};
1366
1367
1368
    auto l1 = mm->add_literal(migraphx::literal{s, {-1.0f, 0.5f, 1.0f}});
    auto l2 = mm->add_literal(migraphx::literal{s, {1.0f, 2.0f, 4.0f}});
    mm->add_instruction(migraphx::op::div{}, l1, l2);
1369
    p.compile(migraphx::ref::target{});
1370
    auto result = p.eval({}).back();
1371
1372
1373
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-1.f, 0.25f, 0.25f};
Paul's avatar
Paul committed
1374
    EXPECT(migraphx::verify_range(results_vector, gold));
1375
1376
}

Paul's avatar
Paul committed
1377
TEST_CASE(relu_test)
Khalique's avatar
Khalique committed
1378
{
Paul's avatar
Paul committed
1379
    migraphx::program p;
1380
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1381
    migraphx::shape s{migraphx::shape::float_type, {3}};
1382
1383
    auto l = mm->add_literal(migraphx::literal{s, {-1.f, 0.f, 1.f}});
    mm->add_instruction(migraphx::op::relu{}, l);
1384
    p.compile(migraphx::ref::target{});
1385
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
1386
1387
1388
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0.f, 0.f, 1.f};
Paul's avatar
Paul committed
1389
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
1390
1391
}

Paul's avatar
Paul committed
1392
TEST_CASE(leaky_relu_test)
Khalique's avatar
Khalique committed
1393
{
Paul's avatar
Paul committed
1394
    migraphx::program p;
1395
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1396
    migraphx::shape s{migraphx::shape::float_type, {3}};
1397
1398
    auto l = mm->add_literal(migraphx::literal{s, {-1.f, 0.f, 1.f}});
    mm->add_instruction(migraphx::op::leaky_relu{0.01}, l);
1399
    p.compile(migraphx::ref::target{});
1400
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
1401
1402
1403
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-0.01f, 0.f, 1.f};
Paul's avatar
Paul committed
1404
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
1405
1406
}

Khalique's avatar
Khalique committed
1407
TEST_CASE(lrn_test)
Khalique's avatar
Khalique committed
1408
{
Khalique's avatar
Khalique committed
1409
    migraphx::program p;
1410
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
1411
    migraphx::shape s{migraphx::shape::float_type, {1, 5, 1, 1}};
1412
1413
    auto l = mm->add_literal(migraphx::literal{s, {-2.0f, 1.0f, 0.f, 1.0f, 2.0f}});
    mm->add_instruction(migraphx::op::lrn{0.0001, 0.75, 1, 5}, l);
1414
    p.compile(migraphx::ref::target{});
1415
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
1416
1417
    std::vector<float> results_vector(5);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Khalique's avatar
Khalique committed
1418
    std::vector<float> gold = {-2 / 1.000075, 1 / 1.00009, 0 / 1.000145, 1 / 1.00009, 2 / 1.000075};
Khalique's avatar
Khalique committed
1419
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
1420
1421
}

Paul's avatar
Paul committed
1422
TEST_CASE(imagescaler_test)
Khalique's avatar
Khalique committed
1423
{
Paul's avatar
Paul committed
1424
    migraphx::program p;
1425
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
1426
    migraphx::shape s{migraphx::shape::float_type, {1, 3, 2, 2}};
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
    auto img           = mm->add_literal(migraphx::literal{s,
                                                 {0.2,
                                                  0.3,
                                                  0.5,
                                                  0.4,

                                                  0.7,
                                                  0.8,
                                                  0.1,
                                                  0.9,

                                                  0.15,
                                                  0.25,
                                                  0.35,
                                                  0.45}});
    auto scale_val     = mm->add_literal(2.f);
    auto scaled_tensor = mm->add_instruction(migraphx::op::scalar{s.lens()}, scale_val);
    auto img_scaled    = mm->add_instruction(migraphx::op::mul{}, img, scaled_tensor);
    auto bias_vals     = mm->add_literal(
Paul's avatar
Paul committed
1446
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
1447
1448
    auto bias_bcast = mm->add_instruction(migraphx::op::broadcast{1, s.lens()}, bias_vals);
    mm->add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);
1449
    p.compile(migraphx::ref::target{});
1450
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
1451
1452
    std::vector<float> results_vector(12);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Khalique's avatar
Khalique committed
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
    std::vector<float> gold = {0.41,
                               0.61,
                               1.01,
                               0.81,

                               1.42,
                               1.62,
                               0.22,
                               1.82,

                               0.33,
                               0.53,
                               0.73,
                               0.93};
Paul's avatar
Paul committed
1467
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
1468
1469
}

Paul's avatar
Paul committed
1470
TEST_CASE(reshape_test)
1471
{
Paul's avatar
Paul committed
1472
    migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
1473
1474
1475
    std::vector<float> data(24);
    std::iota(data.begin(), data.end(), -3);
    {
Paul's avatar
Paul committed
1476
        migraphx::program p;
1477
1478
        auto* mm                       = p.get_main_module();
        auto l                         = mm->add_literal(migraphx::literal{a_shape, data});
1479
        std::vector<int64_t> new_shape = {8, 3, 1, 1};
1480
        mm->add_instruction(migraphx::op::reshape{new_shape}, l);
1481
        p.compile(migraphx::ref::target{});
1482
        auto result = p.eval({}).back();
1483
        std::vector<float> results_vector(3);
1484
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
1485
        EXPECT(migraphx::verify_range(results_vector, data));
1486
1487
    }
    {
Paul's avatar
Paul committed
1488
        migraphx::program p;
1489
1490
        auto* mm                       = p.get_main_module();
        auto l                         = mm->add_literal(migraphx::literal{a_shape, data});
1491
        std::vector<int64_t> new_shape = {1, 3, 4, 2};
1492
        mm->add_instruction(migraphx::op::reshape{new_shape}, l);
1493
        p.compile(migraphx::ref::target{});
1494
        auto result = p.eval({}).back();
1495
        std::vector<float> results_vector(3);
1496
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
1497
        EXPECT(migraphx::verify_range(results_vector, data));
1498
1499
    }
    {
Paul's avatar
Paul committed
1500
        migraphx::program p;
1501
1502
        auto* mm                       = p.get_main_module();
        auto l                         = mm->add_literal(migraphx::literal{a_shape, data});
1503
        std::vector<int64_t> new_shape = {1, 3, 4, 2};
1504
        mm->add_instruction(migraphx::op::reshape{new_shape}, l);
1505
        p.compile(migraphx::ref::target{});
1506
        auto result = p.eval({}).back();
1507
        std::vector<float> results_vector(3);
1508
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
1509
        EXPECT(migraphx::verify_range(results_vector, data));
1510
1511
1512
    }
}

Paul's avatar
Paul committed
1513
TEST_CASE(maxpool_test)
1514
{
Paul's avatar
Paul committed
1515
    migraphx::program p;
1516
    auto* mm             = p.get_main_module();
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
    std::vector<float> a = {
        -2.1314404,  -1.63041711, 1.54562736,  1.04625261,  -1.42931843, -0.48703974, 0.4065806,
        -0.1524526,  1.30775225,  0.45538983,  -0.06631992, -1.75332725, 1.33493888,  0.47327688,
        0.36873096,  1.18358743,  -0.34640595, 1.22098756,  0.01946825,  -0.20238149, 0.43348005,
        -0.67991608, -0.83041084, 0.93537551,  0.70241445,  -0.5654031,  -1.30899191, -0.26735824,
        -0.52444768, 1.99097753,  1.86504853,  -0.26506025, 0.26236168,  0.43763575,  0.95300823,
        -1.02733946, -0.74655169, -0.5374338,  -0.28901565, -0.59789604, 0.5310151,   0.99125904,
        0.40609556,  -1.57175648, 0.22031412,  1.45862222,  0.53217483,  1.39087725,  1.00170159,
        -0.87175864, -1.7204628,  -1.72008383, -0.38656762, -0.01443311, 1.46645272,  -1.39995027,
        0.22505587,  -0.43461126, -0.05511411, -0.79950953, -0.01439556, 0.08795211,  1.18943918,
        -0.84079367, -1.73383629, -0.55662078, -0.30626822, -0.67339015, 0.44179603,  0.54316711,
        0.40899998,  -0.27831686, -1.11900508, -0.0881724,  0.35483059,  2.36277103,  -0.04765317,
        -0.36865309, 0.73814237,  1.47151589,  1.36546791,  -0.32649881, -1.0517807,  2.24768877,
        0.68883753,  0.58646208,  -0.91017133, -0.50462508, -0.4013325,  -0.72348958, -0.47368807,
        0.35285577,  -1.01817429, -0.5152272,  0.60321307,  0.43521205,  -0.23733577, 0.66427642,
        0.82949388,  0.82443929,  0.71550399,  0.34561086,  0.68570769,  -0.40718508, -1.20350206,
        0.15793853,  -2.31013632, -0.07934658, -0.09348056, 0.36576006,  2.46601582,  0.11090943,
        0.9144392,   0.56759721,  -0.22112127, -0.21955389, 0.72474903,  -1.28448462, 1.53285873,
        0.37437943,  0.31409341,  1.95433736,  0.91620457,  0.86205518,  1.24365854,  0.19248386,
        0.22526583,  0.13462132,  -0.27561715, -2.06446075, -0.02306402, -1.38278747, 1.1411345,
        1.31293464,  -1.86041689, 1.06763375,  -0.26541466, 1.4545635,   1.11430049,  -0.66491818,
        0.87101674,  0.67768967,  -1.02062869, -1.05031872, -2.2764678,  -2.0200038,  0.37592548,
        -0.26701379, -0.83388507, 0.19403623,  1.00968623,  0.11020003,  1.16736257,  -1.1160326,
        0.47346735,  0.6126079,   -0.19135755, 1.33624589,  -0.29802522, -0.57873946, -1.06555879,
        -0.20686582, 1.36892557,  -0.19937795, 0.8649236,   -1.40126073, 1.53441942,  0.34682792,
        -1.31724346, -1.32898355, 2.40126371,  0.07845283,  1.35732043,  -0.63678312, 0.39429256,
        -1.36487007, -0.31026676, -0.44981545, -0.28994772, -0.14657612, -1.75206447, -0.70612341,
        1.20071781,  -1.64647579, -0.7133292,  0.88494766,  0.52119428,  -2.77387547, 2.07681108,
        -0.90133125, 0.2847338,   0.6174528,   -0.20616426, -0.64263535, -1.08496261, 0.54275119,
        -0.88503587, 0.6629802,   1.47319221,  -1.05829155, -0.97027361, -0.93187737, -1.39954746,
        -0.52359426, -0.14743951, 1.51522756,  0.2078452,   -1.28156149, -1.19363916, -0.78680223,
        -0.89094824, 1.30212069,  -0.77974445, -0.58411664, 0.48764706,  -0.67132682};
    std::vector<float> c = {1.33493888, 1.54562736, 1.22098756, 1.33493888, 1.18358743, 1.99097753,
                            1.00170159, 1.45862222, 1.39087725, 1.46645272, 1.18943918, -0.01443311,
                            1.47151589, 2.36277103, 2.24768877, 0.68883753, 0.82949388, 0.71550399,
                            1.95433736, 2.46601582, 1.53285873, 1.95433736, 1.06763375, 1.4545635,
                            1.33624589, 1.16736257, 0.6126079,  1.36892557, 2.40126371, 1.53441942,
                            0.52119428, 2.07681108, 0.88494766, 1.51522756, 0.54275119, 0.6629802};
Paul's avatar
Paul committed
1555
    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 6, 6}};
1556
1557
    auto al = mm->add_literal(migraphx::literal{a_shape, a});
    mm->add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{3, 2}}}, al);
1558
    p.compile(migraphx::ref::target{});
1559
    auto result = p.eval({}).back();
1560
1561
    std::vector<float> results_vector(36);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
1562
    EXPECT(migraphx::verify_range(results_vector, c));
1563
1564
}

Khalique's avatar
Khalique committed
1565
1566
1567
TEST_CASE(softmax_simple_test)
{
    migraphx::program p;
1568
    auto* mm             = p.get_main_module();
Khalique's avatar
Khalique committed
1569
1570
    std::vector<float> a = {0.25, 0.75};
    std::vector<float> s = {0.377541, 0.622459};
Khalique's avatar
Khalique committed
1571
    migraphx::shape a_shape{migraphx::shape::float_type, {1, 2}};
1572
1573
    auto al = mm->add_literal(migraphx::literal{a_shape, a});
    mm->add_instruction(migraphx::op::softmax{1}, al);
1574
    p.compile(migraphx::ref::target{});
1575
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
1576
1577
1578
1579
1580
    std::vector<float> results_vector(2);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, s));
}

Paul's avatar
Paul committed
1581
TEST_CASE(softmax_test)
1582
{
Paul's avatar
Paul committed
1583
    migraphx::program p;
1584
    auto* mm             = p.get_main_module();
1585
1586
1587
1588
1589
1590
1591
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
1630
    std::vector<float> a = {
        -5.61869681e-01, 9.07827199e-01,  1.29255986e+00,  3.18533443e-02,  -1.22183852e-03,
        -2.83830553e-01, -1.03245842e+00, -9.28322077e-01, -8.82696748e-01, 1.11327164e-01,
        -9.20038462e-01, 8.47388089e-01,  2.51734018e-01,  1.50563884e+00,  2.23056650e+00,
        -6.17576987e-02, -1.00264274e-01, -6.10369384e-01, 1.17537189e+00,  -2.51560897e-01,
        -8.50333512e-01, -8.03578615e-01, -6.51194930e-01, -2.58137047e-01, 4.65528190e-01,
        3.23284641e-02,  -1.54700470e+00, 1.38096774e+00,  5.39869189e-01,  -7.56884992e-01,
        1.81503093e+00,  -2.11269641e+00, 1.92466557e+00,  1.77230799e+00,  2.21660900e+00,
        1.56777036e+00,  -2.08995026e-03, 3.50566894e-01,  -1.15042710e+00, -1.18577778e+00,
        8.90633047e-01,  -6.63949102e-02, 1.44661188e+00,  1.59215283e+00,  -2.56262213e-01,
        9.39079225e-01,  4.07298543e-02,  3.86590779e-01,  6.09607756e-01,  8.22331488e-01,
        -2.82126725e-01, -9.49052632e-01, -4.24012303e-01, -5.32990396e-01, -3.18386006e+00,
        3.27092171e-01,  -1.33315325e+00, 3.62459183e-01,  3.74710828e-01,  -1.30302286e+00,
        1.79680198e-01,  -4.51832324e-01, 4.34282750e-01,  -7.09520102e-01, 6.20333970e-01,
        -1.28712380e+00, 2.04130828e-01,  -7.70607769e-01, 1.61889160e+00,  -1.50951004e+00,
        -4.10505563e-01, -3.56566496e-02, -1.29747534e+00, -1.49967879e-01, 7.77626812e-01,
        -8.28408226e-02, 2.73412596e-02,  5.79780899e-03,  9.87900198e-02,  -7.95276761e-01,
        -1.38536084e+00, -6.63573861e-01, 3.89783204e-01,  -1.30670881e+00, -7.62425125e-01,
        -4.04883057e-01, 6.24344349e-01,  3.68128955e-01,  -1.01577950e+00, -3.06715906e-01,
        5.67961395e-01,  2.98198581e-01,  -1.63613629e+00, -3.75131965e-01, -6.75393403e-01,
        2.59172034e+00,  6.75538957e-01,  9.07939598e-02,  1.92257717e-01,  -1.21592450e+00,
        -2.73682117e-01, 1.25232983e+00,  -1.39969170e+00, -1.91483587e-01, 2.57732719e-01,
        3.10056299e-01,  1.41833842e+00,  -1.81386679e-01, 3.92868072e-01,  -8.14771175e-01,
        2.02392387e+00,  -9.42091495e-02, -3.77683818e-01, 2.05638766e+00,  2.93796062e-01,
        -6.02131486e-01, 2.70461679e-01,  -8.92358482e-01, 1.04388881e+00,  2.66154885e-01};

    std::vector<float> s = {
        0.30191708, 0.59879845, 0.50029165, 0.24915339, 0.36823985, 0.13190967, 0.0349741,
        0.18750034, 0.21905553, 0.27000085, 0.0547399,  0.56318235, 0.47422904, 0.78964758,
        0.91381913, 0.44601166, 0.47902739, 0.13120073, 0.4449684,  0.18766427, 0.15753111,
        0.07844277, 0.05120674, 0.36648798, 0.14637007, 0.13152322, 0.01560997, 0.29065287,
        0.49196178, 0.10550152, 0.81890774, 0.06369215, 0.62972021, 0.74931765, 0.67285055,
        0.35034987, 0.28612873, 0.31931475, 0.04220394, 0.16093165, 0.22390974, 0.11915915,
        0.3115395,  0.35899726, 0.22190949, 0.57518375, 0.13888834, 0.7753762,  0.4642328,
        0.57055861, 0.21954368, 0.34515455, 0.09486015, 0.40631217, 0.01842281, 0.48770609,
        0.06652815, 0.36023033, 0.42343026, 0.24226256, 0.17348589, 0.44066274, 0.6865865,
        0.17296699, 0.46923906, 0.06921105, 0.3570261,  0.4125829,  0.73165393, 0.15302512,
        0.29499072, 0.33932695, 0.30852377, 0.40762195, 0.40170741, 0.36259529, 0.60848355,
        0.42618036, 0.31721094, 0.02960522, 0.28256637, 0.24389413, 0.2725659,  0.10663581,
        0.27622163, 0.28264219, 0.53652936, 0.09476089, 0.40890986, 0.34848392, 0.32572666,
        0.53076893, 0.11529481, 0.29117745, 0.14625968, 0.8756339,  0.49818122, 0.10656087,
        0.1813329,  0.17664003, 0.21410346, 0.80408043, 0.02315119, 0.27155462, 0.32804728,
        0.13268511, 0.61795473, 0.49703068, 0.41696799, 0.10175809, 0.71028161, 0.29929739,
        0.17377149, 0.76075399, 0.20071237, 0.32632929, 0.36892858, 0.09416146, 0.26656723,
        0.42914796};

Paul's avatar
Paul committed
1631
    migraphx::shape a_shape{migraphx::shape::float_type, {5, 3, 4, 2}};
1632
1633
    auto al = mm->add_literal(migraphx::literal{a_shape, a});
    mm->add_instruction(migraphx::op::softmax{}, al);
1634
    p.compile(migraphx::ref::target{});
1635
    auto result = p.eval({}).back();
1636
    std::vector<float> results_vector(120);
1637
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
1638
    EXPECT(migraphx::verify_range(results_vector, s));
Scott Thornton's avatar
Scott Thornton committed
1639
1640
}

1641
1642
1643
TEST_CASE(logsoftmax_test_axis_0)
{
    migraphx::program p;
1644
    auto* mm             = p.get_main_module();
1645
    std::vector<float> a = {
Shucai Xiao's avatar
Shucai Xiao committed
1646
1647
1648
1649
1650
1651
1652
1653
        1.93885877,  -1.20006269, 0.90960855,  0.42108916,  -1.50797544, -1.31047913, 1.07816336,
        -1.13288733, -0.86411064, 0.97800238,  0.76631385,  2.07962834,  -0.8940665,  -1.62855592,
        -0.53763057, -1.48165117, -0.64154112, 0.42486547,  0.89330917,  -2.42022666, 0.192611,
        -0.01257413, -1.5326607,  0.53137897,  -1.52383859, 0.46994381,  0.00453619,  0.0066996,
        1.58394908,  0.84216752,  -0.04137941, -0.88580789, 1.44055158,  -0.17621241, -1.98917923,
        -0.08610038, 0.79020567,  -0.67714548, 0.42774631,  0.1376574,   2.23569227,  1.16681234,
        -1.21191456, -0.28411502, -0.18688975, 1.67552548,  2.48357974,  0.95891282,  -0.06616535,
        -0.99628491, 1.04314606,  -1.22943315, 0.76930403,  0.31106618};
1654
1655

    std::vector<float> s = {
Shucai Xiao's avatar
Shucai Xiao committed
1656
1657
1658
1659
1660
1661
        -0.135261, -2.843968, -0.659995, -0.488413, -1.051857, -2.812936, -0.250956, -0.353985,
        -1.155980, -0.603651, -0.211969, -0.175371, -1.336552, -3.885010, -1.871544, -0.837083,
        -0.887745, -0.433338, -1.158864, -4.911197, -1.147972, -0.666711, -0.996874, -0.981418,
        -0.851145, -0.853988, -0.858112, -2.067420, -0.059956, -0.727436, -0.950881, -0.429689,
        -0.061906, -1.505332, -1.210277, -0.377970, -0.791448, -1.655428, -1.827253, -0.304828,
        -0.020762, -0.167101, -0.567346, -0.530319, -1.045094, -0.376648, -0.007391, -0.381670,
1662
        -0.720302, -0.460499, -0.469651, -0.556740, -0.554628, -0.551582};
1663
1664

    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
1665
    auto al  = mm->add_literal(migraphx::literal{a_shape, a});
1666
    int axis = 0;
1667
    mm->add_instruction(migraphx::op::logsoftmax{axis}, al);
1668
    p.compile(migraphx::ref::target{});
1669
    auto result = p.eval({}).back();
1670
1671
1672
1673
1674
1675
1676
1677
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, s));
}

TEST_CASE(logsoftmax_test_axis_1)
{
    migraphx::program p;
1678
    auto* mm             = p.get_main_module();
1679
    std::vector<float> a = {
Shucai Xiao's avatar
Shucai Xiao committed
1680
1681
1682
1683
1684
1685
1686
1687
        1.93885877,  -1.20006269, 0.90960855,  0.42108916,  -1.50797544, -1.31047913, 1.07816336,
        -1.13288733, -0.86411064, 0.97800238,  0.76631385,  2.07962834,  -0.8940665,  -1.62855592,
        -0.53763057, -1.48165117, -0.64154112, 0.42486547,  0.89330917,  -2.42022666, 0.192611,
        -0.01257413, -1.5326607,  0.53137897,  -1.52383859, 0.46994381,  0.00453619,  0.0066996,
        1.58394908,  0.84216752,  -0.04137941, -0.88580789, 1.44055158,  -0.17621241, -1.98917923,
        -0.08610038, 0.79020567,  -0.67714548, 0.42774631,  0.1376574,   2.23569227,  1.16681234,
        -1.21191456, -0.28411502, -0.18688975, 1.67552548,  2.48357974,  0.95891282,  -0.06616535,
        -0.99628491, 1.04314606,  -1.22943315, 0.76930403,  0.31106618};
1688
1689

    std::vector<float> s = {
Shucai Xiao's avatar
Shucai Xiao committed
1690
1691
1692
1693
1694
1695
        -0.550468, -2.132973, -1.549746, -0.650533, -1.051529, -2.248570, -0.141017, -2.028357,
        -1.947730, -1.511324, -0.166597, -0.379726, -1.965689, -1.172109, -1.475721, -2.700831,
        -1.537011, -0.658754, -1.596017, -3.353137, -2.266743, -1.084197, -1.076214, -0.406712,
        -2.743019, -0.425526, -1.079083, -2.139486, -1.270584, -1.024088, -1.154231, -3.201762,
        -0.888957, -0.532855, -3.103583, -1.221339, -1.355980, -3.531678, -1.438510, -0.975194,
        -0.080261, -1.162697, -1.568557, -1.398519, -1.322129, -0.470660, -0.370953, -0.907343,
1696
        -1.179017, -3.312239, -1.286363, -1.586076, -0.345100, -0.824173};
1697
1698

    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
1699
    auto al  = mm->add_literal(migraphx::literal{a_shape, a});
1700
    int axis = 1;
1701
    mm->add_instruction(migraphx::op::logsoftmax{axis}, al);
1702
    p.compile(migraphx::ref::target{});
1703
    auto result = p.eval({}).back();
1704
1705
1706
1707
1708
1709
1710
1711
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, s));
}

TEST_CASE(logsoftmax_test_axis_2)
{
    migraphx::program p;
1712
    auto* mm             = p.get_main_module();
1713
    std::vector<float> a = {
Shucai Xiao's avatar
Shucai Xiao committed
1714
1715
1716
1717
1718
1719
1720
1721
        1.93885877,  -1.20006269, 0.90960855,  0.42108916,  -1.50797544, -1.31047913, 1.07816336,
        -1.13288733, -0.86411064, 0.97800238,  0.76631385,  2.07962834,  -0.8940665,  -1.62855592,
        -0.53763057, -1.48165117, -0.64154112, 0.42486547,  0.89330917,  -2.42022666, 0.192611,
        -0.01257413, -1.5326607,  0.53137897,  -1.52383859, 0.46994381,  0.00453619,  0.0066996,
        1.58394908,  0.84216752,  -0.04137941, -0.88580789, 1.44055158,  -0.17621241, -1.98917923,
        -0.08610038, 0.79020567,  -0.67714548, 0.42774631,  0.1376574,   2.23569227,  1.16681234,
        -1.21191456, -0.28411502, -0.18688975, 1.67552548,  2.48357974,  0.95891282,  -0.06616535,
        -0.99628491, 1.04314606,  -1.22943315, 0.76930403,  0.31106618};
1722
1723

    std::vector<float> s = {
Shucai Xiao's avatar
Shucai Xiao committed
1724
1725
1726
1727
1728
1729
        -0.495957, -1.031212, -0.245531, -2.013726, -1.339125, -2.465619, -1.356652, -0.964037,
        -2.019250, -0.214522, -0.289569, -0.234392, -2.086591, -2.684439, -2.851651, -2.674176,
        -1.697424, -1.889155, -0.401029, -3.064586, -1.173030, -1.306912, -2.177020, -0.834262,
        -2.818177, -0.174415, -1.361105, -1.024571, -0.106766, -1.167645, -1.072650, -2.576522,
        -0.569261, -1.207483, -3.679894, -2.095913, -0.504264, -3.039291, -1.290559, -1.156812,
        -0.126453, -0.551493, -2.506384, -2.646261, -1.905195, -0.206994, -0.191369, -0.959754,
1730
        -1.948685, -3.671233, -0.875521, -3.111952, -1.905644, -1.6076011};
1731
1732

    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
1733
    auto al  = mm->add_literal(migraphx::literal{a_shape, a});
1734
    int axis = 2;
1735
    mm->add_instruction(migraphx::op::logsoftmax{axis}, al);
1736
    p.compile(migraphx::ref::target{});
1737
    auto result = p.eval({}).back();
1738
1739
1740
1741
1742
1743
1744
1745
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, s));
}

TEST_CASE(logsoftmax_test_axis_3)
{
    migraphx::program p;
1746
    auto* mm             = p.get_main_module();
1747
    std::vector<float> a = {
Shucai Xiao's avatar
Shucai Xiao committed
1748
1749
1750
1751
1752
1753
1754
1755
        1.93885877,  -1.20006269, 0.90960855,  0.42108916,  -1.50797544, -1.31047913, 1.07816336,
        -1.13288733, -0.86411064, 0.97800238,  0.76631385,  2.07962834,  -0.8940665,  -1.62855592,
        -0.53763057, -1.48165117, -0.64154112, 0.42486547,  0.89330917,  -2.42022666, 0.192611,
        -0.01257413, -1.5326607,  0.53137897,  -1.52383859, 0.46994381,  0.00453619,  0.0066996,
        1.58394908,  0.84216752,  -0.04137941, -0.88580789, 1.44055158,  -0.17621241, -1.98917923,
        -0.08610038, 0.79020567,  -0.67714548, 0.42774631,  0.1376574,   2.23569227,  1.16681234,
        -1.21191456, -0.28411502, -0.18688975, 1.67552548,  2.48357974,  0.95891282,  -0.06616535,
        -0.99628491, 1.04314606,  -1.22943315, 0.76930403,  0.31106618};
1756
1757

    std::vector<float> s = {
Shucai Xiao's avatar
Shucai Xiao committed
1758
1759
1760
1761
1762
1763
        -0.336904, -3.475825, -1.366154, -0.279366, -2.208430, -2.010934, -0.225511, -2.436562,
        -2.167785, -1.572415, -1.784104, -0.470789, -1.067459, -1.801948, -0.711023, -2.307197,
        -1.467087, -0.400681, -0.426983, -3.740518, -1.127681, -1.078919, -2.599005, -0.534965,
        -2.561400, -0.567617, -1.033025, -2.097713, -0.520463, -1.262245, -1.763230, -2.607658,
        -0.281299, -0.814243, -2.627210, -0.724131, -0.655704, -2.123055, -1.018163, -2.480634,
        -0.382599, -1.451479, -1.843102, -0.915303, -0.818078, -1.316929, -0.508875, -2.033541,
1764
        -1.487672, -2.417791, -0.378360, -2.568531, -0.569794, -1.028032};
1765
1766

    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
1767
    auto al  = mm->add_literal(migraphx::literal{a_shape, a});
1768
    int axis = 3;
1769
    mm->add_instruction(migraphx::op::logsoftmax{axis}, al);
1770
    p.compile(migraphx::ref::target{});
1771
    auto result = p.eval({}).back();
1772
1773
1774
1775
1776
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, s));
}

1777
TEST_CASE(argmax_test_0)
1778
1779
{
    migraphx::program p;
1780
    auto* mm                = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1781
1782
1783
    std::vector<float> data = {1.2255,  1.6834,  -2.0305, -0.3221, 0.4701,  0.2583, 0.7545, 2.5758,
                               -1.6849, 0.0928,  0.9022,  -0.8765, -0.4090, 0.9301, 2.0724, -1.5706,
                               0.4867,  -0.1493, 0.6957,  -0.2179, 0.7142,  0.7177, 0.0183, 1.3497};
1784
1785
    std::vector<int64_t> res_gold = {0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1};
    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3, 4}};
1786
1787
    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
    mm->add_instruction(migraphx::op::argmax{0}, dl);
1788
    p.compile(migraphx::ref::target{});
1789
    auto result = p.eval({}).back();
1790
1791
1792
1793
1794
1795
1796
1797
1798
    std::vector<int64_t> result_vec;
    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });

    EXPECT(migraphx::verify_range(result_vec, res_gold));
}

TEST_CASE(argmax_test_1)
{
    migraphx::program p;
1799
    auto* mm                = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1800
1801
1802
    std::vector<float> data = {1.2255,  1.6834,  -2.0305, -0.3221, 0.4701,  0.2583, 0.7545, 2.5758,
                               -1.6849, 0.0928,  0.9022,  -0.8765, -0.4090, 0.9301, 2.0724, -1.5706,
                               0.4867,  -0.1493, 0.6957,  -0.2179, 0.7142,  0.7177, 0.0183, 1.3497};
1803
1804
    std::vector<int64_t> res_gold = {0, 0, 2, 1, 2, 0, 0, 2};
    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3, 4}};
1805
1806
    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
    mm->add_instruction(migraphx::op::argmax{1}, dl);
1807
    p.compile(migraphx::ref::target{});
1808
    auto result = p.eval({}).back();
1809
1810
1811
1812
1813
1814
    std::vector<int64_t> result_vec;
    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });

    EXPECT(migraphx::verify_range(result_vec, res_gold));
}

1815
1816
1817
TEST_CASE(argmax_test_neg_2)
{
    migraphx::program p;
1818
    auto* mm                = p.get_main_module();
1819
1820
1821
1822
1823
    std::vector<float> data = {1.2255,  1.6834,  -2.0305, -0.3221, 0.4701,  0.2583, 0.7545, 2.5758,
                               -1.6849, 0.0928,  0.9022,  -0.8765, -0.4090, 0.9301, 2.0724, -1.5706,
                               0.4867,  -0.1493, 0.6957,  -0.2179, 0.7142,  0.7177, 0.0183, 1.3497};
    std::vector<int64_t> res_gold = {0, 0, 2, 1, 2, 0, 0, 2};
    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3, 4}};
1824
1825
    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
    mm->add_instruction(migraphx::op::argmax{-2}, dl);
1826
    p.compile(migraphx::ref::target{});
1827
    auto result = p.eval({}).back();
1828
1829
1830
1831
1832
1833
    std::vector<int64_t> result_vec;
    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });

    EXPECT(migraphx::verify_range(result_vec, res_gold));
}

1834
1835
1836
TEST_CASE(argmax_test_2)
{
    migraphx::program p;
1837
    auto* mm                = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1838
1839
1840
    std::vector<float> data = {1.2255,  1.6834,  -2.0305, -0.3221, 0.4701,  0.2583, 0.7545, 2.5758,
                               -1.6849, 0.0928,  0.9022,  -0.8765, -0.4090, 0.9301, 2.0724, -1.5706,
                               0.4867,  -0.1493, 0.6957,  -0.2179, 0.7142,  0.7177, 0.0183, 1.3497};
1841
1842
    std::vector<int64_t> res_gold = {1, 3, 2, 2, 2, 3};
    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3, 4}};
1843
1844
    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
    mm->add_instruction(migraphx::op::argmax{2}, dl);
1845
    p.compile(migraphx::ref::target{});
1846
    auto result = p.eval({}).back();
1847
1848
1849
1850
1851
1852
    std::vector<int64_t> result_vec;
    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });

    EXPECT(migraphx::verify_range(result_vec, res_gold));
}

1853
TEST_CASE(argmin_test_0)
1854
1855
{
    migraphx::program p;
1856
    auto* mm                = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1857
1858
1859
    std::vector<float> data = {1.2255,  1.6834,  -2.0305, -0.3221, 0.4701,  0.2583, 0.7545, 2.5758,
                               -1.6849, 0.0928,  0.9022,  -0.8765, -0.4090, 0.9301, 2.0724, -1.5706,
                               0.4867,  -0.1493, 0.6957,  -0.2179, 0.7142,  0.7177, 0.0183, 1.3497};
1860
1861
    std::vector<int64_t> res_gold = {1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0};
    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3, 4}};
1862
1863
    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
    mm->add_instruction(migraphx::op::argmin{0}, dl);
1864
    p.compile(migraphx::ref::target{});
1865
    auto result = p.eval({}).back();
1866
1867
1868
1869
1870
1871
1872
1873
1874
    std::vector<int64_t> result_vec;
    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });

    EXPECT(migraphx::verify_range(result_vec, res_gold));
}

TEST_CASE(argmin_test_1)
{
    migraphx::program p;
1875
    auto* mm                = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1876
1877
1878
    std::vector<float> data = {1.2255,  1.6834,  -2.0305, -0.3221, 0.4701,  0.2583, 0.7545, 2.5758,
                               -1.6849, 0.0928,  0.9022,  -0.8765, -0.4090, 0.9301, 2.0724, -1.5706,
                               0.4867,  -0.1493, 0.6957,  -0.2179, 0.7142,  0.7177, 0.0183, 1.3497};
1879
1880
    std::vector<int64_t> res_gold = {2, 2, 0, 2, 0, 1, 2, 0};
    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3, 4}};
1881
1882
    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
    mm->add_instruction(migraphx::op::argmin{1}, dl);
1883
    p.compile(migraphx::ref::target{});
1884
    auto result = p.eval({}).back();
1885
1886
1887
1888
1889
1890
1891
1892
1893
    std::vector<int64_t> result_vec;
    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });

    EXPECT(migraphx::verify_range(result_vec, res_gold));
}

TEST_CASE(argmin_test_2)
{
    migraphx::program p;
1894
    auto* mm                = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1895
1896
1897
    std::vector<float> data = {1.2255,  1.6834,  -2.0305, -0.3221, 0.4701,  0.2583, 0.7545, 2.5758,
                               -1.6849, 0.0928,  0.9022,  -0.8765, -0.4090, 0.9301, 2.0724, -1.5706,
                               0.4867,  -0.1493, 0.6957,  -0.2179, 0.7142,  0.7177, 0.0183, 1.3497};
1898
1899
    std::vector<int64_t> res_gold = {2, 1, 0, 3, 3, 2};
    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3, 4}};
1900
1901
    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
    mm->add_instruction(migraphx::op::argmin{2}, dl);
1902
    p.compile(migraphx::ref::target{});
1903
    auto result = p.eval({}).back();
1904
1905
1906
1907
1908
1909
    std::vector<int64_t> result_vec;
    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });

    EXPECT(migraphx::verify_range(result_vec, res_gold));
}

1910
1911
1912
TEST_CASE(argmin_test_neg_1)
{
    migraphx::program p;
1913
    auto* mm                = p.get_main_module();
1914
1915
1916
1917
1918
    std::vector<float> data = {1.2255,  1.6834,  -2.0305, -0.3221, 0.4701,  0.2583, 0.7545, 2.5758,
                               -1.6849, 0.0928,  0.9022,  -0.8765, -0.4090, 0.9301, 2.0724, -1.5706,
                               0.4867,  -0.1493, 0.6957,  -0.2179, 0.7142,  0.7177, 0.0183, 1.3497};
    std::vector<int64_t> res_gold = {2, 1, 0, 3, 3, 2};
    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3, 4}};
1919
1920
    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
    mm->add_instruction(migraphx::op::argmin{-1}, dl);
1921
    p.compile(migraphx::ref::target{});
1922
    auto result = p.eval({}).back();
1923
1924
1925
1926
1927
1928
    std::vector<int64_t> result_vec;
    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });

    EXPECT(migraphx::verify_range(result_vec, res_gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
1929
1930
1931
TEST_CASE(neg_test)
{
    migraphx::program p;
1932
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
1933
1934
    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
    std::vector<float> data = {1.0f, 1.3f, -1.2f, 0.0f, -100.f, 200.f};
1935
1936
1937
    auto input              = mm->add_literal(migraphx::literal(s, data));
    auto ret                = mm->add_instruction(migraphx::op::neg{}, input);
    mm->add_return({ret});
1938
    p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
1939
1940
1941
1942
1943
1944
1945
1946
    auto result = p.eval({}).back();
    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

    std::vector<float> gold = {-1.0f, -1.3f, 1.2f, 0.0f, 100.f, -200.f};
    EXPECT(migraphx::verify_range(result_vector, gold));
}

Paul's avatar
Paul committed
1947
TEST_CASE(conv2d_test)
1948
{
Paul's avatar
Paul committed
1949
    migraphx::program p;
1950
    auto* mm             = p.get_main_module();
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
    std::vector<float> a = {
        2.71567607,  -0.9960829,  0.91671127,  0.28140706,  0.63235772,  0.08077253,  0.80927712,
        -0.59108931, -1.05421555, -2.76622486, -0.85044265, -0.52049929, 0.67726439,  -0.65290606,
        0.02345525,  -0.33579525, 0.38901961,  1.05473483,  -1.31188095, 1.8963089,   -0.07265259,
        0.947339,    0.41949373,  -0.70814759, 0.25892952,  1.07311416,  1.2571274,   -0.62318051,
        -0.19951548, -0.94232577, -0.29393643, 0.42292568,  -0.80230367, 1.40909171,  0.63617158,
        0.13900366,  1.09253144,  -0.15265895, 1.54781747,  0.72780299,  1.09189606,  -0.38068101,
        0.97057933,  -0.58958799, 1.56188643,  0.21474874,  0.58725154,  -1.27097559, -0.03024297,
        1.09437096,  -0.4897908,  0.34838957,  -1.31042492, -1.69069934, 0.86956722,  -0.40457946,
        0.46691212,  1.29273605,  0.26464137,  0.22073045,  -1.02178168, 0.22163901,  -1.84387338,
        0.75522131,  -0.45775682, -0.42241111, -1.50944722, 1.07256448,  -1.95876884, -0.28106022,
        0.3341668,   2.13129425,  -1.14728117, -1.06555498, -0.298444,   -0.88322699, -0.65866792,
        -2.06007552, 0.01374334,  0.45612028,  0.52715492,  1.01914406,  -1.72659791, 0.80650896,
        0.16860051,  2.24112225,  -0.78620857, 0.36566174,  -0.07020134, -0.47976932, -0.68230027,
        -0.94711417, -0.54506505, 1.66504931,  -0.71860826, 0.61132306};

    std::vector<float> c = {
        2.82721668e-02,  6.44195229e-02,  1.53499246e-02,  1.72468081e-01,  -6.33238107e-02,
        9.49496776e-02,  1.40258059e-01,  -7.92879611e-02, -1.29301161e-01, 3.11307609e-03,
        -1.90624535e-01, 1.13238767e-01,  -2.80647576e-02, 3.12882811e-02,  -3.52091640e-02,
        3.33581865e-02,  6.43158704e-02,  7.40238279e-02,  -1.00106120e-01, -9.56912562e-02,
        1.44342467e-01,  9.40258950e-02,  6.36333972e-02,  1.66158378e-03,  -8.91554281e-02,
        2.58734226e-02,  1.70919895e-02,  1.78214177e-01,  8.84564668e-02,  8.98126513e-02,
        -1.63809001e-01, 1.37802169e-01,  1.66439757e-01,  -1.45631135e-02, 1.88469887e-04,
        4.76950556e-02,  -1.91969007e-01, -1.76233292e-01, -7.70473927e-02, 1.14828631e-01,
        1.76608220e-01,  -1.50728196e-01, 1.99946314e-02,  -5.88052124e-02, 1.31612435e-01,
        1.61106288e-02,  -1.35080189e-01, 1.49512306e-01,  3.86456847e-02,  1.29330024e-01,
        -3.22975963e-02, -5.60784787e-02, -5.41997552e-02, 4.78562862e-02};

    std::vector<float> s = {0.27039781,
                            0.19105849,
                            -0.06339942,
                            -0.65087199,
                            0.40867025,
                            0.05063812,
                            -0.14907975,
                            0.49018705,
                            -0.49197209,
                            0.33236548,
                            -0.39374301,
                            0.16012701,
                            0.06574871,
                            0.71606487,
                            -0.55201721,
Scott Thornton's avatar
Scott Thornton committed
1995
                            -0.46427044};
Paul's avatar
Paul committed
1996
    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
1997
    auto al = mm->add_literal(migraphx::literal{a_shape, a});
Scott Thornton's avatar
Scott Thornton committed
1998

Paul's avatar
Paul committed
1999
    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
2000
    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
Scott Thornton's avatar
Scott Thornton committed
2001

2002
    mm->add_instruction(migraphx::op::convolution{}, al, cl);
2003
    p.compile(migraphx::ref::target{});
2004
    auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
2005
2006

    std::vector<float> results_vector(16);
2007
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
2008
    EXPECT(migraphx::verify_range(results_vector, s));
Scott Thornton's avatar
Scott Thornton committed
2009
2010
}

Paul Fultz II's avatar
Paul Fultz II committed
2011
2012
2013
TEST_CASE(conv3d_test)
{
    migraphx::program p;
2014
    auto* mm             = p.get_main_module();
Paul Fultz II's avatar
Paul Fultz II committed
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
    std::vector<float> a = {
        2.71567607,  -0.9960829,  0.91671127,  0.28140706,  0.63235772,  0.08077253,  0.80927712,
        -0.59108931, -1.05421555, -2.76622486, -0.85044265, -0.52049929, 0.67726439,  -0.65290606,
        0.02345525,  -0.33579525, 0.38901961,  1.05473483,  -1.31188095, 1.8963089,   -0.07265259,
        0.947339,    0.41949373,  -0.70814759, 0.25892952,  1.07311416,  1.2571274,   -0.62318051,
        -0.19951548, -0.94232577, -0.29393643, 0.42292568,  -0.80230367, 1.40909171,  0.63617158,
        0.13900366,  1.09253144,  -0.15265895, 1.54781747,  0.72780299,  1.09189606,  -0.38068101,
        0.97057933,  -0.58958799, 1.56188643,  0.21474874,  0.58725154,  -1.27097559, -0.03024297,
        1.09437096,  -0.4897908,  0.34838957,  -1.31042492, -1.69069934, 0.86956722,  -0.40457946,
        0.46691212,  1.29273605,  0.26464137,  0.22073045,  -1.02178168, 0.22163901,  -1.84387338,
        0.75522131,  -0.45775682, -0.42241111, -1.50944722, 1.07256448,  -1.95876884, -0.28106022,
        0.3341668,   2.13129425,  -1.14728117, -1.06555498, -0.298444,   -0.88322699, -0.65866792,
        -2.06007552, 0.01374334,  0.45612028,  0.52715492,  1.01914406,  -1.72659791, 0.80650896,
        0.16860051,  2.24112225,  -0.78620857, 0.36566174,  -0.07020134, -0.47976932, -0.68230027,
        -0.94711417, -0.54506505, 1.66504931,  -0.71860826, 0.61132306};

    std::vector<float> c = {
        2.82721668e-02,  6.44195229e-02,  1.53499246e-02,  1.72468081e-01,  -6.33238107e-02,
        9.49496776e-02,  1.40258059e-01,  -7.92879611e-02, -1.29301161e-01, 3.11307609e-03,
        -1.90624535e-01, 1.13238767e-01,  -2.80647576e-02, 3.12882811e-02,  -3.52091640e-02,
        3.33581865e-02,  6.43158704e-02,  7.40238279e-02,  -1.00106120e-01, -9.56912562e-02,
        1.44342467e-01,  9.40258950e-02,  6.36333972e-02,  1.66158378e-03,  -8.91554281e-02,
        2.58734226e-02,  1.70919895e-02,  1.78214177e-01,  8.84564668e-02,  8.98126513e-02,
        -1.63809001e-01, 1.37802169e-01,  1.66439757e-01,  -1.45631135e-02, 1.88469887e-04,
        4.76950556e-02,  -1.91969007e-01, -1.76233292e-01, -7.70473927e-02, 1.14828631e-01,
        1.76608220e-01,  -1.50728196e-01, 1.99946314e-02,  -5.88052124e-02, 1.31612435e-01,
        1.61106288e-02,  -1.35080189e-01, 1.49512306e-01,  3.86456847e-02,  1.29330024e-01,
        -3.22975963e-02, -5.60784787e-02, -5.41997552e-02, 4.78562862e-02};

    std::vector<float> s = {0.27039781,
                            0.19105849,
                            -0.06339942,
                            -0.65087199,
                            0.40867025,
                            0.05063812,
                            -0.14907975,
                            0.49018705,
                            -0.49197209,
                            0.33236548,
                            -0.39374301,
                            0.16012701,
                            0.06574871,
                            0.71606487,
                            -0.55201721,
                            -0.46427044};
    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4, 1}};
2061
    auto al = mm->add_literal(migraphx::literal{a_shape, a});
Paul Fultz II's avatar
Paul Fultz II committed
2062
2063

    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3, 1}};
2064
    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
Paul Fultz II's avatar
Paul Fultz II committed
2065

2066
    mm->add_instruction(migraphx::op::convolution{{0, 0, 0}, {1, 1, 1}, {1, 1, 1}}, al, cl);
2067
    p.compile(migraphx::ref::target{});
Paul Fultz II's avatar
Paul Fultz II committed
2068
2069
2070
2071
2072
2073
2074
    auto result = p.eval({}).back();

    std::vector<float> results_vector(16);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, s));
}

Paul's avatar
Paul committed
2075
TEST_CASE(conv2d_padding_test)
2076
{
Paul's avatar
Paul committed
2077
    migraphx::program p;
2078
    auto* mm             = p.get_main_module();
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
    std::vector<float> a = {
        2.71567607,  -0.9960829,  0.91671127,  0.28140706,  0.63235772,  0.08077253,  0.80927712,
        -0.59108931, -1.05421555, -2.76622486, -0.85044265, -0.52049929, 0.67726439,  -0.65290606,
        0.02345525,  -0.33579525, 0.38901961,  1.05473483,  -1.31188095, 1.8963089,   -0.07265259,
        0.947339,    0.41949373,  -0.70814759, 0.25892952,  1.07311416,  1.2571274,   -0.62318051,
        -0.19951548, -0.94232577, -0.29393643, 0.42292568,  -0.80230367, 1.40909171,  0.63617158,
        0.13900366,  1.09253144,  -0.15265895, 1.54781747,  0.72780299,  1.09189606,  -0.38068101,
        0.97057933,  -0.58958799, 1.56188643,  0.21474874,  0.58725154,  -1.27097559, -0.03024297,
        1.09437096,  -0.4897908,  0.34838957,  -1.31042492, -1.69069934, 0.86956722,  -0.40457946,
        0.46691212,  1.29273605,  0.26464137,  0.22073045,  -1.02178168, 0.22163901,  -1.84387338,
        0.75522131,  -0.45775682, -0.42241111, -1.50944722, 1.07256448,  -1.95876884, -0.28106022,
        0.3341668,   2.13129425,  -1.14728117, -1.06555498, -0.298444,   -0.88322699, -0.65866792,
        -2.06007552, 0.01374334,  0.45612028,  0.52715492,  1.01914406,  -1.72659791, 0.80650896,
        0.16860051,  2.24112225,  -0.78620857, 0.36566174,  -0.07020134, -0.47976932, -0.68230027,
        -0.94711417, -0.54506505, 1.66504931,  -0.71860826, 0.61132306};

    std::vector<float> c = {
        -0.16115488, -0.09800646, -0.05412646, 0.10475694,  0.00555485,  -0.12667653, 0.0458357,
        -0.02656217, -0.16338061, 0.15037455,  0.0102711,   0.01303349,  0.05242859,  0.02034754,
        0.04751867,  -0.17038961, -0.1434752,  -0.10770349, 0.05676742,  -0.15838449, 0.10128359,
        -0.18958683, 0.11954515,  0.10758857,  -0.01058291, -0.12797487, 0.08971019,  0.18793164,
        -0.00881396, -0.06588994, -0.13321903, -0.03300409, 0.01439607,  0.07618178,  -0.11556662,
        0.00764295,  0.12956454,  -0.08937147, -0.12763587, 0.04674943,  0.05765297,  0.11336918,
        0.14747436,  -0.06199479, -0.01166052, -0.12432006, -0.04494537, -0.17581205, 0.09475745,
        0.1149437,   -0.1014564,  0.0274073,   -0.01323579, -0.11092556};

    std::vector<float> s = {
        -0.0201216,  0.40407312,  -0.39005592, -0.0631946,  0.37963012,  -0.64611685, 0.1349397,
        -0.54113752, 0.28533003,  0.27667275,  -0.16442731, -0.181494,   0.30564839,  0.58744538,
        0.32015014,  0.24969585,  -0.27367792, -0.53308117, 0.41236052,  0.26136363,  -0.01489828,
        0.57652152,  -0.38506854, 0.119615,    0.0437076,   0.04779706,  0.57887721,  0.23126155,
        0.05695833,  -0.68200272, 0.02063358,  -0.10267162, 0.8062973,   -0.38149622, -0.40134856,
        -0.03353126, 0.38991132,  -0.3478111,  0.03661491,  0.25783631,  0.62772679,  -0.1961118,
        0.76423508,  -0.36241418, -0.20994355, -0.12368261, -0.9406727,  0.02340185,  -0.08793129,
        -0.02471633, -0.58163726, -0.02211772, -0.42014724, 0.77525634,  0.504951,    -0.20537445,
        -0.20369984, -0.83037728, -1.40423918, -0.46160448, -0.22944322, 0.36074194,  0.49579027,
        0.46527559};

Paul's avatar
Paul committed
2117
    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
2118
    auto al = mm->add_literal(migraphx::literal{a_shape, a});
Scott Thornton's avatar
Scott Thornton committed
2119

Paul's avatar
Paul committed
2120
    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
2121
    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
Scott Thornton's avatar
Scott Thornton committed
2122

2123
    mm->add_instruction(migraphx::op::convolution{{{1, 1}}, {{1, 1}}}, al, cl);
2124
    p.compile(migraphx::ref::target{});
2125
    auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
2126
2127

    std::vector<float> results_vector(64);
2128
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
2129
    EXPECT(migraphx::verify_range(results_vector, s));
2130
2131
}

Paul's avatar
Paul committed
2132
TEST_CASE(conv2d_padding_stride_test)
2133
{
Paul's avatar
Paul committed
2134
    migraphx::program p;
2135
    auto* mm             = p.get_main_module();
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
    std::vector<float> a = {
        2.71567607,  -0.9960829,  0.91671127,  0.28140706,  0.63235772,  0.08077253,  0.80927712,
        -0.59108931, -1.05421555, -2.76622486, -0.85044265, -0.52049929, 0.67726439,  -0.65290606,
        0.02345525,  -0.33579525, 0.38901961,  1.05473483,  -1.31188095, 1.8963089,   -0.07265259,
        0.947339,    0.41949373,  -0.70814759, 0.25892952,  1.07311416,  1.2571274,   -0.62318051,
        -0.19951548, -0.94232577, -0.29393643, 0.42292568,  -0.80230367, 1.40909171,  0.63617158,
        0.13900366,  1.09253144,  -0.15265895, 1.54781747,  0.72780299,  1.09189606,  -0.38068101,
        0.97057933,  -0.58958799, 1.56188643,  0.21474874,  0.58725154,  -1.27097559, -0.03024297,
        1.09437096,  -0.4897908,  0.34838957,  -1.31042492, -1.69069934, 0.86956722,  -0.40457946,
        0.46691212,  1.29273605,  0.26464137,  0.22073045,  -1.02178168, 0.22163901,  -1.84387338,
        0.75522131,  -0.45775682, -0.42241111, -1.50944722, 1.07256448,  -1.95876884, -0.28106022,
        0.3341668,   2.13129425,  -1.14728117, -1.06555498, -0.298444,   -0.88322699, -0.65866792,
        -2.06007552, 0.01374334,  0.45612028,  0.52715492,  1.01914406,  -1.72659791, 0.80650896,
        0.16860051,  2.24112225,  -0.78620857, 0.36566174,  -0.07020134, -0.47976932, -0.68230027,
        -0.94711417, -0.54506505, 1.66504931,  -0.71860826, 0.61132306};

    std::vector<float> c = {
        -0.14601797, -0.13000923, 0.06521662,  0.06178288,  -0.11083675, 0.10154136,  0.09990512,
        0.06030385,  -0.11374587, -0.17523311, -0.14344215, 0.17802463,  0.06300922,  -0.15325832,
        0.07066704,  0.05166031,  0.00615084,  -0.02606523, 0.08083995,  -0.17913306, 0.0624622,
        0.0735731,   -0.04198661, -0.0164391,  -0.06374192, 0.16569914,  0.10681538,  0.07370754,
        0.02802075,  0.00282027,  0.15104802,  -0.11084409, -0.00197773, 0.07924436,  0.03528272,
        0.04765259,  -0.15896152, 0.07917164,  0.12125669,  -0.1154705,  -0.11999125, 0.12749968,
        -0.06269585, 0.18658121,  -0.03944227, 0.0111798,   -0.17731084, 0.11789055,  -0.09982193,
        0.08142821,  0.0729029,   0.11303909,  0.12735154,  0.03885292};

    std::vector<float> s = {-0.20817225,
                            0.87965256,
                            0.14958936,
                            -1.24887264,
                            -0.06540672,
                            0.20778663,
                            0.40456355,
                            -0.99900877,
                            0.4917807,
                            0.1994698,
                            0.64205718,
                            0.37798831,
                            -0.25315839,
                            0.44276932,
                            -0.16138598,
                            0.79344082};

Paul's avatar
Paul committed
2179
    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
2180
    auto al = mm->add_literal(migraphx::literal{a_shape, a});
Scott Thornton's avatar
Scott Thornton committed
2181

Paul's avatar
Paul committed
2182
    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
2183
    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
Scott Thornton's avatar
Scott Thornton committed
2184

2185
    mm->add_instruction(migraphx::op::convolution{{{1, 1}}, {{2, 2}}}, al, cl);
2186
    p.compile(migraphx::ref::target{});
2187
    auto result = p.eval({}).back();
Scott Thornton's avatar
Scott Thornton committed
2188
2189

    std::vector<float> results_vector(16);
2190
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
2191
    EXPECT(migraphx::verify_range(results_vector, s));
Scott Thornton's avatar
Scott Thornton committed
2192
}
2193

2194
2195
2196
TEST_CASE(quant_conv2d_test)
{
    migraphx::program p;
2197
    auto* mm = p.get_main_module();
2198
2199
2200
    migraphx::shape a_shape{migraphx::shape::int8_type, {2, 3, 4, 4}};
    std::vector<int8_t> a(2 * 3 * 4 * 4);
    std::iota(a.begin(), a.end(), 0);
2201
    auto al = mm->add_literal(migraphx::literal{a_shape, a});
2202
2203
2204
2205

    migraphx::shape c_shape{migraphx::shape::int8_type, {2, 3, 3, 3}};
    std::vector<int8_t> c(2 * 3 * 3 * 3);
    std::iota(c.begin(), c.end(), 0);
2206
    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
2207

2208
    mm->add_instruction(migraphx::op::quant_convolution{}, al, cl);
2209
    p.compile(migraphx::ref::target{});
2210
    auto result = p.eval({}).back();
2211

2212
    std::vector<int32_t> s = {10197,
Shucai Xiao's avatar
Shucai Xiao committed
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
                              10548,
                              11601,
                              11952,
                              25506,
                              26586,
                              29826,
                              30906,
                              27045,
                              27396,
                              28449,
                              28800,
                              77346,
                              78426,
                              81666,
                              82746};
2228

2229
    std::vector<int32_t> results_vector;
2230
2231
2232
2233
2234
2235
2236
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, s));
}

TEST_CASE(quant_conv2d_padding_test)
{
    migraphx::program p;
2237
    auto* mm = p.get_main_module();
2238
2239
2240
    migraphx::shape a_shape{migraphx::shape::int8_type, {2, 3, 4, 4}};
    std::vector<int8_t> a(2 * 3 * 4 * 4);
    std::iota(a.begin(), a.end(), 0);
2241
    auto al = mm->add_literal(migraphx::literal{a_shape, a});
2242
2243
2244
    migraphx::shape c_shape{migraphx::shape::int8_type, {2, 3, 3, 3}};
    std::vector<int8_t> c(2 * 3 * 3 * 3);
    std::iota(c.begin(), c.end(), 0);
2245
2246
    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
    mm->add_instruction(migraphx::op::quant_convolution{{{1, 1}}, {{1, 1}}}, al, cl);
2247
    p.compile(migraphx::ref::target{});
2248
    auto result            = p.eval({}).back();
2249
    std::vector<int32_t> s = {
Shucai Xiao's avatar
Shucai Xiao committed
2250
2251
2252
2253
2254
        4521,  6753,  7014,  4635,  6858,  10197, 10548, 6939,  7830,  11601, 11952, 7839,  5007,
        7383,  7590,  4953,  10515, 15987, 16734, 11277, 16821, 25506, 26586, 17874, 19737, 29826,
        30906, 20718, 13593, 20505, 21198, 14187, 13161, 19281, 19542, 12699, 18522, 27045, 27396,
        17739, 19494, 28449, 28800, 18639, 11919, 17319, 17526, 11289, 34707, 51843, 52590, 34893,
        51813, 77346, 78426, 52002, 54729, 81666, 82746, 54846, 36057, 53769, 54462, 36075};
2255

2256
    std::vector<int32_t> results_vector;
2257
2258
2259
2260
2261
2262
2263
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, s));
}

TEST_CASE(quant_conv2d_padding_stride_test)
{
    migraphx::program p;
2264
    auto* mm = p.get_main_module();
2265
2266
2267
    migraphx::shape a_shape{migraphx::shape::int8_type, {2, 3, 4, 4}};
    std::vector<int8_t> a(2 * 3 * 4 * 4);
    std::iota(a.begin(), a.end(), 0);
2268
    auto al = mm->add_literal(migraphx::literal{a_shape, a});
2269
2270
2271
    migraphx::shape c_shape{migraphx::shape::int8_type, {2, 3, 3, 3}};
    std::vector<int8_t> c(2 * 3 * 3 * 3);
    std::iota(c.begin(), c.end(), 0);
2272
2273
    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
    mm->add_instruction(migraphx::op::quant_convolution{{{1, 1}}, {{2, 2}}}, al, cl);
2274
    p.compile(migraphx::ref::target{});
2275
    auto result = p.eval({}).back();
2276

2277
    std::vector<int32_t> s = {4521,
Shucai Xiao's avatar
Shucai Xiao committed
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
                              7014,
                              7830,
                              11952,
                              10515,
                              16734,
                              19737,
                              30906,
                              13161,
                              19542,
                              19494,
                              28800,
                              34707,
                              52590,
                              54729,
                              82746};
2293
    std::vector<int32_t> results_vector;
2294
2295
2296
2297
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, s));
}

kahmed10's avatar
kahmed10 committed
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
TEST_CASE(deconv_test)
{
    migraphx::shape s{migraphx::shape::float_type, {1, 1, 3, 3}};
    std::vector<float> x_data{0, 1, 2, 3, 4, 5, 6, 7, 8};
    std::vector<float> w_data{1, 1, 1, 1, 1, 1, 1, 1, 1};

    std::vector<float> gold{0,  1,  3, 3,  2,  3,  8,  15, 12, 7,  9,  21, 36,
                            27, 15, 9, 20, 33, 24, 13, 6,  13, 21, 15, 8};

    migraphx::program p;
2308
2309
2310
    auto* mm = p.get_main_module();
    auto x   = mm->add_literal(migraphx::literal{s, x_data});
    auto w   = mm->add_literal(migraphx::literal{s, w_data});
kahmed10's avatar
kahmed10 committed
2311

2312
    mm->add_instruction(migraphx::op::deconvolution{}, x, w);
2313
    p.compile(migraphx::ref::target{});
2314
    auto result = p.eval({}).back();
kahmed10's avatar
kahmed10 committed
2315
2316
2317
2318
2319
2320

    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, gold));
}

kahmed10's avatar
kahmed10 committed
2321
2322
2323
2324
2325
2326
2327
2328
2329
TEST_CASE(deconv_1d_test)
{
    migraphx::shape s{migraphx::shape::float_type, {1, 1, 3}};
    std::vector<float> x_data{0, 0.5, 1};
    std::vector<float> w_data{0.5, 0.5, 0.5};

    std::vector<float> gold{0, 0.25, 0.75, 0.75, 0.5};

    migraphx::program p;
2330
2331
2332
    auto* mm = p.get_main_module();
    auto x   = mm->add_literal(migraphx::literal{s, x_data});
    auto w   = mm->add_literal(migraphx::literal{s, w_data});
kahmed10's avatar
kahmed10 committed
2333

2334
    mm->add_instruction(migraphx::op::deconvolution{{0}, {1}, {1}}, x, w);
2335
    p.compile(migraphx::ref::target{});
kahmed10's avatar
kahmed10 committed
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
    auto result = p.eval({}).back();

    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(deconv_3d_test)
{
    migraphx::shape s_1{migraphx::shape::float_type, {1, 1, 1, 2, 3}};
    migraphx::shape s_2{migraphx::shape::float_type, {1, 1, 3, 2, 3}};
    std::vector<float> x_data{0.8471, -0.4195, -2.2749, 1.2491, 0.1722, 0.3246};
    std::vector<float> w_data{0.6478,
                              -0.1985,
                              0.0633,
                              -0.3479,
                              2.7056,
                              -0.1440,
                              -1.1229,
                              -0.7507,
                              -1.3151,
                              0.8884,
                              -0.1859,
                              -0.3407,
                              -1.1544,
                              -1.5893,
                              1.6265,
                              -1.4624,
                              0.3812,
                              -1.5378};

    std::vector<float> gold{0.5488,  -0.4399, -1.3369, 0.4251,  -0.1439, 0.5145,  2.3015,  -0.2104,
                            -6.1482, 0.3482,  -0.4346, 3.3197,  0.1731,  0.8533,  -0.0467, -0.9512,
                            -0.1649, 1.7553,  2.2594,  2.9917,  -0.6500, -1.6612, -4.3680, 0.0957,
                            0.3482,  1.1097,  -0.0792, -0.1692, -0.1190, -0.1106, -0.9779, -0.8621,
                            4.6707,  2.9332,  -3.7001, -2.6808, -1.2476, 3.2475,  -0.4578, 4.0263,
                            -1.8267, 0.2243,  -2.3299, -0.1411, -0.4991};

    migraphx::program p;
2375
2376
2377
    auto* mm = p.get_main_module();
    auto x   = mm->add_literal(migraphx::literal{s_1, x_data});
    auto w   = mm->add_literal(migraphx::literal{s_2, w_data});
kahmed10's avatar
kahmed10 committed
2378

2379
    mm->add_instruction(migraphx::op::deconvolution{{0, 0, 0}, {1, 1, 1}, {1, 1, 1}}, x, w);
2380
    p.compile(migraphx::ref::target{});
kahmed10's avatar
kahmed10 committed
2381
2382
2383
2384
2385
2386
2387
    auto result = p.eval({}).back();

    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Paul's avatar
Paul committed
2388
TEST_CASE(transpose_test)
2389
{
Paul's avatar
Paul committed
2390
    migraphx::shape a_shape{migraphx::shape::float_type, {1, 2, 2, 3}};
2391
2392
2393
    std::vector<float> data(12);
    std::iota(data.begin(), data.end(), 0);

2394
    {
Paul's avatar
Paul committed
2395
        migraphx::program p;
2396
2397
        auto* mm                  = p.get_main_module();
        auto l                    = mm->add_literal(migraphx::literal{a_shape, data});
Paul's avatar
Paul committed
2398
        std::vector<int64_t> perm = {0, 3, 1, 2};
2399
        mm->add_instruction(migraphx::op::transpose{perm}, l);
2400
        p.compile(migraphx::ref::target{});
2401
        auto result = p.eval({}).back();
2402

Paul's avatar
Paul committed
2403
        result.visit([&](auto output) {
Paul's avatar
Paul committed
2404
            std::vector<size_t> new_lens = {1, 3, 2, 2};
Paul's avatar
Paul committed
2405
2406
            EXPECT(bool{output.get_shape().lens() == new_lens});
        });
2407
2408
    }
    {
Paul's avatar
Paul committed
2409
        migraphx::program p;
2410
2411
        auto* mm                  = p.get_main_module();
        auto l                    = mm->add_literal(migraphx::literal{a_shape, data});
Paul's avatar
Paul committed
2412
        std::vector<int64_t> perm = {0, 3, 1, 2};
2413
2414
        auto result               = mm->add_instruction(migraphx::op::transpose{perm}, l);
        mm->add_instruction(migraphx::op::contiguous{}, result);
2415
        p.compile(migraphx::ref::target{});
2416
        auto result2 = p.eval({}).back();
2417
2418
2419
2420

        std::vector<float> results_vector(12);
        result2.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
        std::vector<float> gold = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
Paul's avatar
Paul committed
2421
        EXPECT(migraphx::verify_range(results_vector, gold));
2422
    }
2423
2424
}

Paul's avatar
Paul committed
2425
TEST_CASE(contiguous_test)
Paul's avatar
Paul committed
2426
{
Paul's avatar
Paul committed
2427
    migraphx::shape a_shape{migraphx::shape::float_type, {1, 3, 2, 2}, {12, 1, 6, 3}};
2428
2429
2430
    std::vector<float> data(12);
    std::iota(data.begin(), data.end(), 0);

Paul's avatar
Paul committed
2431
    migraphx::program p;
2432
2433
2434
    auto* mm = p.get_main_module();
    auto l   = mm->add_literal(migraphx::literal{a_shape, data});
    mm->add_instruction(migraphx::op::contiguous{}, l);
2435
    p.compile(migraphx::ref::target{});
2436
    auto result = p.eval({}).back();
2437
2438

    std::vector<float> results_vector(12);
2439
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
2440
2441
    std::vector<size_t> new_lens    = {1, 3, 2, 2};
    std::vector<size_t> new_strides = {12, 1, 6, 3};
2442
    EXPECT(migraphx::verify_range(results_vector, data));
2443
2444
}

Khalique's avatar
Khalique committed
2445
2446
TEST_CASE(identity_test)
{
Khalique's avatar
Khalique committed
2447
    migraphx::program p;
2448
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2449
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
Khalique's avatar
Khalique committed
2450
    std::vector<int> data{1, 2, 3, 4};
2451
2452
    auto l = mm->add_literal(migraphx::literal{s, data});
    mm->add_instruction(migraphx::op::identity{}, l);
2453
    p.compile(migraphx::ref::target{});
2454
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
2455
2456
2457
2458
2459
    std::vector<int> results_vector(4);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(std::equal(data.begin(), data.end(), results_vector.begin()));
}

Khalique's avatar
Khalique committed
2460
2461
2462
TEST_CASE(abs_test)
{
    migraphx::program p;
2463
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2464
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
2465
2466
    auto l = mm->add_literal(migraphx::literal{s, {-1, 2, -3, 4}});
    mm->add_instruction(migraphx::op::abs{}, l);
2467
    p.compile(migraphx::ref::target{});
2468
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
2469
2470
2471
2472
2473
2474
2475
2476
2477
    std::vector<float> results_vector(4);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{1, 2, 3, 4};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(sigmoid_test)
{
    migraphx::program p;
2478
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2479
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
2480
2481
    auto l = mm->add_literal(migraphx::literal{s, {-1, 2, -3, 4}});
    mm->add_instruction(migraphx::op::sigmoid{}, l);
2482
    p.compile(migraphx::ref::target{});
2483
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
2484
2485
2486
2487
2488
2489
    std::vector<float> results_vector(4);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{sigmoid(-1), sigmoid(2), sigmoid(-3), sigmoid(4)};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

2490
2491
2492
TEST_CASE(sinh_test)
{
    migraphx::program p;
2493
    auto* mm = p.get_main_module();
2494
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
2495
2496
    auto l = mm->add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
    mm->add_instruction(migraphx::op::sinh{}, l);
2497
    p.compile(migraphx::ref::target{});
2498
    auto result = p.eval({}).back();
2499
2500
2501
2502
2503
2504
2505
2506
2507
    std::vector<float> results_vector(4);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{sinhf(-1), sinhf(2), sinhf(-3), sinhf(4)};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(cosh_test)
{
    migraphx::program p;
2508
    auto* mm = p.get_main_module();
2509
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
2510
2511
    auto l = mm->add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
    mm->add_instruction(migraphx::op::cosh{}, l);
2512
    p.compile(migraphx::ref::target{});
2513
    auto result = p.eval({}).back();
2514
2515
2516
2517
2518
2519
    std::vector<float> results_vector(4);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{coshf(-1), coshf(2), coshf(-3), coshf(4)};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Khalique's avatar
Khalique committed
2520
2521
2522
TEST_CASE(tanh_test)
{
    migraphx::program p;
2523
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2524
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
2525
2526
    auto l = mm->add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
    mm->add_instruction(migraphx::op::tanh{}, l);
2527
    p.compile(migraphx::ref::target{});
2528
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
2529
2530
2531
2532
2533
2534
2535
2536
2537
    std::vector<float> results_vector(4);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{tanhf(-1), tanhf(2), tanhf(-3), tanhf(4)};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(elu_test)
{
    migraphx::program p;
2538
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2539
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
2540
    auto l      = mm->add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
Khalique's avatar
Khalique committed
2541
    float alpha = 0.5;
2542
    mm->add_instruction(migraphx::op::elu{alpha}, l);
2543
    p.compile(migraphx::ref::target{});
2544
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
2545
2546
    std::vector<float> results_vector(4);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Khalique's avatar
Khalique committed
2547
    std::vector<float> gold{elu(alpha, -1), elu(alpha, 2), elu(alpha, -3), elu(alpha, 4)};
Khalique's avatar
Khalique committed
2548
2549
2550
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Khalique's avatar
Khalique committed
2551
2552
2553
TEST_CASE(max_test)
{
    migraphx::program p;
2554
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2555
    migraphx::shape s{migraphx::shape::float_type, {3}};
2556
2557
2558
2559
2560
    auto l0       = mm->add_literal(migraphx::literal{s, {1, 4, 3}});
    auto l1       = mm->add_literal(migraphx::literal{s, {2, 8, 6}});
    auto l2       = mm->add_literal(migraphx::literal{s, {7, 5, 9}});
    auto curr_max = mm->add_instruction(migraphx::op::max{}, l0, l1);
    mm->add_instruction(migraphx::op::max{}, curr_max, l2);
2561
    p.compile(migraphx::ref::target{});
2562
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
2563
2564
2565
2566
2567
2568
2569
2570
2571
    std::vector<float> results_vector(4);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{7, 8, 9};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(min_test)
{
    migraphx::program p;
2572
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2573
    migraphx::shape s{migraphx::shape::float_type, {3}};
2574
2575
2576
2577
2578
    auto l0       = mm->add_literal(migraphx::literal{s, {1, 4, 3}});
    auto l1       = mm->add_literal(migraphx::literal{s, {2, 8, 6}});
    auto l2       = mm->add_literal(migraphx::literal{s, {7, 5, 9}});
    auto curr_min = mm->add_instruction(migraphx::op::min{}, l0, l1);
    mm->add_instruction(migraphx::op::min{}, curr_min, l2);
2579
    p.compile(migraphx::ref::target{});
2580
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
2581
2582
2583
2584
2585
2586
    std::vector<float> results_vector(4);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{1, 4, 3};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

2587
2588
2589
TEST_CASE(pad_test)
{
    migraphx::program p;
2590
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2591
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
2592
2593
    auto l0 = mm->add_literal(migraphx::literal{s, {1, 2, 3, 4}});
    mm->add_instruction(migraphx::op::pad{{1, 1, 1, 1}}, l0);
2594
    p.compile(migraphx::ref::target{});
2595
    auto result = p.eval({}).back();
2596
2597
    std::vector<float> results_vector(16);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Khalique's avatar
Khalique committed
2598
    std::vector<float> gold{0, 0, 0, 0, 0, 1, 2, 0, 0, 3, 4, 0, 0, 0, 0, 0};
2599
2600
2601
    EXPECT(migraphx::verify_range(results_vector, gold));
}

2602
2603
2604
TEST_CASE(pad_test_lowest_half)
{
    migraphx::program p;
2605
    auto* mm = p.get_main_module();
2606
    migraphx::shape s{migraphx::shape::half_type, {2, 2}};
2607
2608
    auto l0 = mm->add_literal(migraphx::literal{s, {1, 2, 3, 4}});
    mm->add_instruction(migraphx::op::pad{{1, 1, 1, 1}, std::numeric_limits<float>::lowest()}, l0);
2609
    p.compile(migraphx::ref::target{});
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
    auto result = p.eval({}).back();
    std::vector<float> results_vector(16);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    const float x = std::numeric_limits<migraphx::half>::lowest();
    std::vector<float> gold{x, x, x, x, x, 1, 2, x, x, 3, 4, x, x, x, x, x};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(pad_test_highest_half)
{
    migraphx::program p;
2621
    auto* mm = p.get_main_module();
2622
    migraphx::shape s{migraphx::shape::half_type, {2, 2}};
2623
2624
    auto l0 = mm->add_literal(migraphx::literal{s, {1, 2, 3, 4}});
    mm->add_instruction(migraphx::op::pad{{1, 1, 1, 1}, std::numeric_limits<float>::max()}, l0);
2625
    p.compile(migraphx::ref::target{});
2626
2627
2628
2629
2630
2631
2632
2633
    auto result = p.eval({}).back();
    std::vector<float> results_vector(16);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    const float x = std::numeric_limits<migraphx::half>::max();
    std::vector<float> gold{x, x, x, x, x, 1, 2, x, x, 3, 4, x, x, x, x, x};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

2634
2635
2636
TEST_CASE(fp16_test)
{
    migraphx::program p;
2637
    auto* mm = p.get_main_module();
2638
2639
2640
2641
    migraphx::shape s{migraphx::shape::half_type, {1}};
    migraphx::half a{1.5};
    migraphx::half b{2.5};
    migraphx::half c{4.0};
2642
2643
2644
    auto l0 = mm->add_literal(migraphx::literal{s, {a}});
    auto l1 = mm->add_literal(migraphx::literal{s, {b}});
    mm->add_instruction(migraphx::op::add{}, l0, l1);
2645
    p.compile(migraphx::ref::target{});
2646
    auto result = p.eval({}).back();
2647
2648
2649
2650
2651
2652
    std::vector<migraphx::half> results_vector(1);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<migraphx::half> gold{c};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

2653
2654
2655
2656
TEST_CASE(fp32_fp16_test)
{
    auto create_program = [] {
        migraphx::program p;
2657
        auto* mm = p.get_main_module();
2658
2659
2660
        migraphx::shape s{migraphx::shape::float_type, {2, 3}};
        std::vector<float> data(2 * 3);
        std::iota(data.begin(), data.end(), 1.0f);
2661
2662
2663
        auto l1 = mm->add_literal(migraphx::literal(s, data));
        auto l2 = mm->add_literal(migraphx::literal(s, data));
        mm->add_instruction(migraphx::op::add{}, l1, l2);
2664
2665
2666
        return p;
    };

Shucai Xiao's avatar
Shucai Xiao committed
2667
    auto test_case = [&](std::vector<std::string>&& op_names) {
2668
        std::vector<float> gold_res = {2.0, 4.0, 6.0, 8.0, 10.0, 12.0};
Shucai Xiao's avatar
Shucai Xiao committed
2669
        auto p                      = create_program();
Shucai Xiao's avatar
Shucai Xiao committed
2670
        migraphx::quantize_fp16(p, op_names);
2671
        p.compile(migraphx::ref::target{});
2672
        auto result = p.eval({}).back();
2673
2674
2675
        std::vector<float> res;
        result.visit([&](auto output) { res.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res, gold_res));
2676
    };
2677

2678
2679
    test_case({"all"});
    test_case({"add"});
2680
2681
}

Khalique's avatar
Khalique committed
2682
2683
2684
TEST_CASE(clip_test)
{
    migraphx::program p;
2685
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2686
    migraphx::shape s{migraphx::shape::float_type, {3}};
2687
2688
2689
2690
2691
2692
    auto l       = mm->add_literal(migraphx::literal{s, {-1.0, 0.0, 10.0}});
    auto min_val = mm->add_literal(0.0f);
    auto max_val = mm->add_literal(6.0f);
    min_val      = mm->add_instruction(migraphx::op::multibroadcast{{3}}, min_val);
    max_val      = mm->add_instruction(migraphx::op::multibroadcast{{3}}, max_val);
    mm->add_instruction(migraphx::op::clip{}, l, min_val, max_val);
2693
    p.compile(migraphx::ref::target{});
2694
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
2695
2696
2697
2698
2699
2700
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0.0, 0.0, 6.0};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
2701
2702
2703
TEST_CASE(reduce_prod_axis0)
{
    migraphx::program p;
2704
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2705
2706
    migraphx::shape s{migraphx::shape::float_type, {4, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 3, 2, 3}};
2707
2708
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_prod{{0}}, l0);
2709
    p.compile(migraphx::ref::target{});
2710
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2711
2712
2713
2714
2715
2716
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{6, 18, 12, 18};
    EXPECT(results_vector == gold);
}

2717
TEST_CASE(reduce_sum_axis0)
Paul's avatar
Paul committed
2718
2719
{
    migraphx::program p;
2720
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
2721
2722
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2723
2724
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_sum{{0}}, l0);
2725
    p.compile(migraphx::ref::target{});
2726
    auto result = p.eval({}).back();
Paul's avatar
Paul committed
2727
2728
2729
2730
2731
2732
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{15, 18, 21, 24};
    EXPECT(results_vector == gold);
}

2733
TEST_CASE(reduce_sum_axis1)
Paul's avatar
Paul committed
2734
2735
{
    migraphx::program p;
2736
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
2737
2738
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2739
2740
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_sum{{1}}, l0);
2741
    p.compile(migraphx::ref::target{});
2742
    auto result = p.eval({}).back();
Paul's avatar
Paul committed
2743
2744
2745
2746
2747
2748
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{4, 6, 12, 14, 20, 22};
    EXPECT(results_vector == gold);
}

2749
TEST_CASE(reduce_sum_axis2)
Paul's avatar
Paul committed
2750
2751
{
    migraphx::program p;
2752
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
2753
2754
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2755
2756
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_sum{{2}}, l0);
2757
    p.compile(migraphx::ref::target{});
2758
    auto result = p.eval({}).back();
Paul's avatar
Paul committed
2759
2760
2761
2762
2763
2764
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{3, 7, 11, 15, 19, 23};
    EXPECT(results_vector == gold);
}

2765
TEST_CASE(reduce_sum_axis02)
Paul's avatar
Paul committed
2766
2767
{
    migraphx::program p;
2768
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
2769
2770
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2771
2772
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_sum{{0, 2}}, l0);
2773
    p.compile(migraphx::ref::target{});
2774
    auto result = p.eval({}).back();
Paul's avatar
Paul committed
2775
2776
2777
2778
2779
2780
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{33, 45};
    EXPECT(results_vector == gold);
}

2781
TEST_CASE(reduce_sum_axis12)
Paul's avatar
Paul committed
2782
2783
{
    migraphx::program p;
2784
    auto* mm = p.get_main_module();
Paul's avatar
Paul committed
2785
2786
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2787
2788
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_sum{{1, 2}}, l0);
2789
    p.compile(migraphx::ref::target{});
2790
    auto result = p.eval({}).back();
Paul's avatar
Paul committed
2791
2792
2793
2794
2795
2796
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{10, 26, 42};
    EXPECT(results_vector == gold);
}

Khalique's avatar
Khalique committed
2797
2798
2799
TEST_CASE(rsqrt_test)
{
    migraphx::program p;
2800
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2801
    migraphx::shape s{migraphx::shape::float_type, {3}};
2802
2803
    auto l = mm->add_literal(migraphx::literal{s, {4.0, 16.0, 64.0}});
    mm->add_instruction(migraphx::op::rsqrt{}, l);
2804
    p.compile(migraphx::ref::target{});
2805
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
2806
2807
2808
2809
2810
2811
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0.5, 0.25, 0.125};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

2812
TEST_CASE(reduce_mean_axis1)
Shucai Xiao's avatar
Shucai Xiao committed
2813
2814
{
    migraphx::program p;
2815
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2816
2817
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2818
2819
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_mean{{1}}, l0);
2820
    p.compile(migraphx::ref::target{});
2821
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2822
2823
2824
2825
2826
2827
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{2, 3, 6, 7, 10, 11};
    EXPECT(results_vector == gold);
}

2828
TEST_CASE(reduce_mean_axis2)
Shucai Xiao's avatar
Shucai Xiao committed
2829
2830
{
    migraphx::program p;
2831
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2832
2833
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2834
2835
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_mean{{2}}, l0);
2836
    p.compile(migraphx::ref::target{});
2837
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2838
2839
2840
2841
2842
2843
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{1.5f, 3.5f, 5.5f, 7.5f, 9.5f, 11.5f};
    EXPECT(results_vector == gold);
}

2844
TEST_CASE(reduce_mean_axis02)
Shucai Xiao's avatar
Shucai Xiao committed
2845
2846
{
    migraphx::program p;
2847
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2848
2849
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2850
2851
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_mean{{0, 2}}, l0);
2852
    p.compile(migraphx::ref::target{});
2853
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2854
2855
2856
2857
2858
2859
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{5.5, 7.5};
    EXPECT(results_vector == gold);
}

2860
TEST_CASE(reduce_mean_axis12)
Shucai Xiao's avatar
Shucai Xiao committed
2861
2862
{
    migraphx::program p;
2863
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2864
2865
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2866
2867
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_mean{{1, 2}}, l0);
2868
    p.compile(migraphx::ref::target{});
2869
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2870
2871
2872
2873
2874
2875
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{2.5f, 6.5f, 10.5f};
    EXPECT(results_vector == gold);
}

Shucai Xiao's avatar
Shucai Xiao committed
2876
2877
2878
TEST_CASE(reduce_mean_int)
{
    migraphx::program p;
2879
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2880
2881
    migraphx::shape s{migraphx::shape::int32_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2882
2883
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_mean{{1, 2}}, l0);
2884
    p.compile(migraphx::ref::target{});
2885
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2886
2887
2888
2889
2890
2891
    std::vector<int> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<int> gold{2, 6, 10};
    EXPECT(results_vector == gold);
}

Shucai Xiao's avatar
Shucai Xiao committed
2892
2893
2894
TEST_CASE(reduce_min_axis1)
{
    migraphx::program p;
2895
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2896
2897
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2898
2899
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_min{{1}}, l0);
2900
    p.compile(migraphx::ref::target{});
2901
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2902
2903
2904
2905
2906
2907
2908
2909
2910
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{1, 2, 5, 6, 9, 10};
    EXPECT(results_vector == gold);
}

TEST_CASE(reduce_min_axis02)
{
    migraphx::program p;
2911
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2912
2913
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2914
2915
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_min{{0, 2}}, l0);
2916
    p.compile(migraphx::ref::target{});
2917
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2918
2919
2920
2921
2922
2923
2924
2925
2926
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{1, 3};
    EXPECT(results_vector == gold);
}

TEST_CASE(reduce_min_axis12)
{
    migraphx::program p;
2927
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2928
2929
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2930
2931
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_min{{1, 2}}, l0);
2932
    p.compile(migraphx::ref::target{});
2933
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2934
2935
2936
2937
2938
2939
2940
2941
2942
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{1, 5, 9};
    EXPECT(results_vector == gold);
}

TEST_CASE(reduce_max_axis0)
{
    migraphx::program p;
2943
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2944
2945
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2946
2947
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_max{{0}}, l0);
2948
    p.compile(migraphx::ref::target{});
2949
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2950
2951
2952
2953
2954
2955
2956
2957
2958
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{9, 10, 11, 12};
    EXPECT(results_vector == gold);
}

TEST_CASE(reduce_max_axis01)
{
    migraphx::program p;
2959
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2960
2961
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2962
2963
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_max{{0, 1}}, l0);
2964
    p.compile(migraphx::ref::target{});
2965
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2966
2967
2968
2969
2970
2971
2972
2973
2974
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{11, 12};
    EXPECT(results_vector == gold);
}

TEST_CASE(reduce_max_axis02)
{
    migraphx::program p;
2975
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
2976
2977
    migraphx::shape s{migraphx::shape::float_type, {3, 2, 2}};
    auto input = migraphx::literal{s, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
2978
2979
    auto l0    = mm->add_literal(input);
    mm->add_instruction(migraphx::op::reduce_max{{0, 2}}, l0);
2980
    p.compile(migraphx::ref::target{});
2981
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
2982
2983
2984
2985
2986
2987
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold{10, 12};
    EXPECT(results_vector == gold);
}

Khalique's avatar
Khalique committed
2988
2989
2990
TEST_CASE(sqdiff_test)
{
    migraphx::program p;
2991
    auto* mm = p.get_main_module();
Khalique's avatar
Khalique committed
2992
    migraphx::shape s{migraphx::shape::float_type, {3}};
2993
2994
2995
    auto l1 = mm->add_literal(migraphx::literal{s, {-1, 0, 1}});
    auto l2 = mm->add_literal(migraphx::literal{s, {1, 2, 3}});
    mm->add_instruction(migraphx::op::sqdiff{}, l1, l2);
2996
    p.compile(migraphx::ref::target{});
2997
    auto result = p.eval({}).back();
Khalique's avatar
Khalique committed
2998
2999
3000
3001
3002
3003
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {4, 4, 4};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

3004
3005
3006
TEST_CASE(round_test)
{
    migraphx::program p;
3007
    auto* mm = p.get_main_module();
3008
    migraphx::shape s{migraphx::shape::float_type, {9}};
3009
3010
3011
    auto l =
        mm->add_literal(migraphx::literal{s, {1.1, 1.5, 1.6, -1.1, -1.5, -1.6, 0.0, 2.0, -2.0}});
    mm->add_instruction(migraphx::op::round{}, l);
3012
    p.compile(migraphx::ref::target{});
3013
    auto result = p.eval({}).back();
3014
3015
3016
3017
3018
3019
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {1.0, 2.0, 2.0, -1.0, -2.0, -2.0, 0.0, 2.0, -2.0};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
3020
3021
3022
TEST_CASE(ceil_test)
{
    migraphx::program p;
3023
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
3024
    migraphx::shape s{migraphx::shape::float_type, {9}};
3025
3026
3027
    auto l =
        mm->add_literal(migraphx::literal{s, {1.1, 1.5, 1.6, -1.1, -1.5, -1.6, 0.0, 2.0, -2.0}});
    mm->add_instruction(migraphx::op::ceil{}, l);
3028
    p.compile(migraphx::ref::target{});
3029
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
3030
3031
3032
3033
3034
3035
3036
3037
3038
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {2.0, 2.0, 2.0, -1.0, -1.0, -1.0, 0.0, 2.0, -2.0};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

TEST_CASE(floor_test)
{
    migraphx::program p;
3039
    auto* mm = p.get_main_module();
Shucai Xiao's avatar
Shucai Xiao committed
3040
    migraphx::shape s{migraphx::shape::float_type, {9}};
3041
3042
3043
    auto l =
        mm->add_literal(migraphx::literal{s, {1.1, 1.5, 0.6, -1.1, -1.5, -0.6, 0.0, 2.0, -2.0}});
    mm->add_instruction(migraphx::op::floor{}, l);
3044
    p.compile(migraphx::ref::target{});
3045
    auto result = p.eval({}).back();
Shucai Xiao's avatar
Shucai Xiao committed
3046
3047
3048
3049
3050
3051
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {1.0, 1.0, 0.0, -2.0, -2.0, -1.0, -0.0, 2.0, -2.0};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

3052
3053
3054
TEST_CASE(op_capture)
{
    migraphx::program p;
3055
    auto* mm = p.get_main_module();
3056
3057
    migraphx::shape s1{migraphx::shape::float_type, {3, 3}};
    migraphx::shape s2{migraphx::shape::float_type, {3, 6}};
Shucai Xiao's avatar
Shucai Xiao committed
3058
3059
    std::vector<float> d1(s1.elements());
    std::vector<float> d2(s2.elements());
3060
3061
3062
    std::iota(d1.begin(), d1.end(), 0.0f);
    std::iota(d2.begin(), d2.end(), 0.0f);

3063
3064
3065
3066
3067
3068
3069
    auto p1 = mm->add_literal(s1, d1);
    auto p2 = mm->add_literal(s1, d1);
    auto pb = mm->add_literal(s2, d2);
    auto pc = mm->add_literal(s2, d2);
    auto pa = mm->add_instruction(migraphx::op::add{}, p1, p2);
    auto ps = mm->add_instruction(migraphx::op::dot{}, pa, pb, pc);
    mm->add_instruction(migraphx::op::dot{}, pa, ps);
3070
3071

    migraphx::program capture_p = p;
3072
    migraphx::target t          = migraphx::ref::target{};
Shucai Xiao's avatar
Shucai Xiao committed
3073
    migraphx::capture_arguments(capture_p, t, {"dot"});
3074

3075
3076
    p.compile(migraphx::ref::target{});
    capture_p.compile(migraphx::ref::target{});
3077

3078
3079
    auto cap_res = capture_p.eval({}).back();
    auto res     = p.eval({}).back();
3080

Shucai Xiao's avatar
Shucai Xiao committed
3081
    std::vector<float> vec;
Shucai Xiao's avatar
Shucai Xiao committed
3082
    std::vector<float> cap_vec;
3083
3084
3085
3086
    cap_res.visit([&](auto output) { cap_vec.assign(output.begin(), output.end()); });
    res.visit([&](auto output) { vec.assign(output.begin(), output.end()); });

    EXPECT(migraphx::verify_range(vec, cap_vec));
3087
}
3088

kahmed10's avatar
kahmed10 committed
3089
3090
3091
TEST_CASE(recip_test)
{
    migraphx::program p;
3092
    auto* mm = p.get_main_module();
kahmed10's avatar
kahmed10 committed
3093
3094
    migraphx::shape s{migraphx::shape::double_type, {3}};
    std::vector<float> data{-0.5f, 0.1f, 0.5f};
3095
3096
    auto l = mm->add_literal(migraphx::literal{s, data});
    mm->add_instruction(migraphx::op::recip{}, l);
3097
    p.compile(migraphx::ref::target{});
kahmed10's avatar
kahmed10 committed
3098
3099
3100
3101
3102
3103
3104
    auto result = p.eval({}).back();
    std::vector<float> results_vector(3);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {-2.0f, 10.0f, 2.0f};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

3105
3106
3107
TEST_CASE(equal_test)
{
    migraphx::program p;
3108
    auto* mm = p.get_main_module();
3109
3110
    migraphx::shape s{migraphx::shape::float_type, {9}};
    auto l0 =
3111
        mm->add_literal(migraphx::literal{s, {1.1, 1.5, 0.1, -1.1, -1.5, -0.6, 0.0, 2.0, -2.0}});
3112
    auto l1 =
3113
3114
3115
3116
        mm->add_literal(migraphx::literal{s, {1.1, 1.6, -0.1, -1.2, -1.5, -0.7, 0.0, 2.3, -2.1}});
    auto eq = mm->add_instruction(migraphx::op::equal{}, l0, l1);
    auto r  = mm->add_instruction(migraphx::op::convert{migraphx::shape::bool_type}, eq);
    mm->add_return({r});
3117

3118
    p.compile(migraphx::ref::target{});
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
    auto result = p.eval({}).back();
    std::vector<bool> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<bool> gold = {true, false, false, false, true, false, true, false, false};
    EXPECT(results_vector == gold);
}

TEST_CASE(equal_brcst_test)
{
    migraphx::program p;
3129
    auto* mm = p.get_main_module();
3130
3131
    migraphx::shape s0{migraphx::shape::float_type, {3, 3}};
    auto l0 =
3132
        mm->add_literal(migraphx::literal{s0, {1.1, 1.5, 0.1, -1.1, -1.5, -0.6, 0.0, 2.0, -2.0}});
3133
    migraphx::shape s1{migraphx::shape::float_type, {3, 1}};
3134
3135
3136
3137
3138
    auto l1  = mm->add_literal(migraphx::literal{s1, {1.1, -1.5, 0.0}});
    auto bl1 = mm->add_instruction(migraphx::op::multibroadcast{{3, 3}}, l1);
    auto eq  = mm->add_instruction(migraphx::op::equal{}, l0, bl1);
    auto r   = mm->add_instruction(migraphx::op::convert{migraphx::shape::bool_type}, eq);
    mm->add_return({r});
3139

3140
    p.compile(migraphx::ref::target{});
3141
3142
3143
3144
3145
3146
3147
    auto result = p.eval({}).back();
    std::vector<bool> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<bool> gold = {true, false, false, false, true, false, true, false, false};
    EXPECT(results_vector == gold);
}

3148
3149
3150
TEST_CASE(greater_test)
{
    migraphx::program p;
3151
    auto* mm = p.get_main_module();
3152
3153
    migraphx::shape s{migraphx::shape::float_type, {9}};
    auto l0 =
3154
        mm->add_literal(migraphx::literal{s, {1.1, 1.5, 0.1, -1.1, -1.5, -0.6, 0.0, 2.0, -2.0}});
3155
    auto l1 =
3156
3157
3158
3159
        mm->add_literal(migraphx::literal{s, {1.1, 1.6, -0.1, -1.2, -1.5, -0.7, 0.0, 2.3, -2.1}});
    auto gr = mm->add_instruction(migraphx::op::greater{}, l0, l1);
    auto r  = mm->add_instruction(migraphx::op::convert{migraphx::shape::bool_type}, gr);
    mm->add_return({r});
3160

3161
    p.compile(migraphx::ref::target{});
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
    auto result = p.eval({}).back();
    std::vector<bool> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<bool> gold = {false, false, true, true, false, true, false, false, true};
    EXPECT(results_vector == gold);
}

TEST_CASE(greater_brcst_test)
{
    migraphx::program p;
3172
    auto* mm = p.get_main_module();
3173
3174
    migraphx::shape s0{migraphx::shape::float_type, {3, 3}};
    auto l0 =
3175
        mm->add_literal(migraphx::literal{s0, {1.1, 1.5, 0.1, -1.1, -1.5, -0.6, 0.0, 2.0, -2.0}});
3176
    migraphx::shape s1{migraphx::shape::float_type, {3, 1}};
3177
3178
3179
3180
3181
    auto l1  = mm->add_literal(migraphx::literal{s1, {1.1, -1.5, 0.0}});
    auto bl1 = mm->add_instruction(migraphx::op::multibroadcast{{3, 3}}, l1);
    auto gr  = mm->add_instruction(migraphx::op::greater{}, l0, bl1);
    auto r   = mm->add_instruction(migraphx::op::convert{migraphx::shape::bool_type}, gr);
    mm->add_return({r});
3182

3183
    p.compile(migraphx::ref::target{});
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
    auto result = p.eval({}).back();
    std::vector<bool> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<bool> gold = {false, true, false, true, false, true, false, true, false};
    EXPECT(results_vector == gold);
}

TEST_CASE(less_test)
{
    migraphx::program p;
3194
    auto* mm = p.get_main_module();
3195
3196
    migraphx::shape s{migraphx::shape::float_type, {9}};
    auto l0 =
3197
        mm->add_literal(migraphx::literal{s, {1.1, 1.5, 0.1, -1.1, -1.5, -0.6, 0.0, 2.0, -2.0}});
3198
    auto l1 =
3199
3200
3201
3202
        mm->add_literal(migraphx::literal{s, {1.1, 1.6, -0.1, -1.2, -1.5, -0.7, 0.0, 2.3, -2.1}});
    auto le = mm->add_instruction(migraphx::op::less{}, l0, l1);
    auto r  = mm->add_instruction(migraphx::op::convert{migraphx::shape::bool_type}, le);
    mm->add_return({r});
3203

3204
    p.compile(migraphx::ref::target{});
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
    auto result = p.eval({}).back();
    std::vector<bool> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<bool> gold = {false, true, false, false, false, false, false, true, false};
    EXPECT(results_vector == gold);
}

TEST_CASE(less_brcst_test)
{
    migraphx::program p;
3215
    auto* mm = p.get_main_module();
3216
3217
    migraphx::shape s0{migraphx::shape::float_type, {3, 3}};
    auto l0 =
3218
        mm->add_literal(migraphx::literal{s0, {1.1, 1.5, 0.1, -1.1, -1.5, -0.6, 0.0, 2.0, -2.0}});
3219
    migraphx::shape s1{migraphx::shape::float_type, {3, 1}};
3220
3221
3222
3223
3224
    auto l1  = mm->add_literal(migraphx::literal{s1, {1.1, -1.5, 0.0}});
    auto bl1 = mm->add_instruction(migraphx::op::multibroadcast{{3, 3}}, l1);
    auto le  = mm->add_instruction(migraphx::op::less{}, l0, bl1);
    auto r   = mm->add_instruction(migraphx::op::convert{migraphx::shape::bool_type}, le);
    mm->add_return({r});
3225

3226
    p.compile(migraphx::ref::target{});
3227
3228
3229
3230
3231
3232
3233
    auto result = p.eval({}).back();
    std::vector<bool> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<bool> gold = {false, false, true, false, false, false, false, false, true};
    EXPECT(results_vector == gold);
}

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