cpu_ops_test.cpp 78.3 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>
Paul's avatar
Paul committed
7
8
#include <migraphx/cpu/target.hpp>
#include <migraphx/verify.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
9
#include <migraphx/onnx.hpp>
10
#include "test.hpp"
11
#include <migraphx/half.hpp>
Scott Thornton's avatar
Scott Thornton committed
12

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

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

Paul's avatar
Paul committed
17
TEST_CASE(slice_test)
Scott Thornton's avatar
Scott Thornton committed
18
{
Scott Thornton's avatar
Scott Thornton committed
19
    {
Paul's avatar
Paul committed
20
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
21
22
        std::vector<int> data(2 * 2 * 3);
        std::iota(data.begin(), data.end(), 0);
Paul's avatar
Paul committed
23
24
25
26
        migraphx::shape s{migraphx::shape::int32_type, {2, 2, 3}};
        auto l0 = p.add_literal(migraphx::literal{s, data});
        p.add_instruction(migraphx::op::slice{{2}, {1}, {3}}, l0);
        migraphx::shape s2{migraphx::shape::int32_type, {2, 2, 2}, {6, 3, 1}};
Scott Thornton's avatar
Scott Thornton committed
27
        EXPECT(p.get_shape() == s2);
Paul's avatar
Paul committed
28
29
        p.compile(migraphx::cpu::target{});
        migraphx::shape sresult{migraphx::shape::int32_type, {2, 2, 2}, {4, 2, 1}};
Scott Thornton's avatar
Scott Thornton committed
30
31
32
33
        auto result           = p.eval({});
        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
34
        EXPECT(migraphx::verify_range(results_vector, gold));
Scott Thornton's avatar
Scott Thornton committed
35
36
37
        EXPECT(result.get_shape() == sresult);
    }
    {
Paul's avatar
Paul committed
38
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
39
40
        std::vector<int> data(2 * 2 * 3);
        std::iota(data.begin(), data.end(), 0);
Paul's avatar
Paul committed
41
42
43
44
        migraphx::shape s{migraphx::shape::int32_type, {2, 2, 3}};
        auto l0 = p.add_literal(migraphx::literal{s, data});
        p.add_instruction(migraphx::op::slice{{0, 1, 2}, {0, 0, 0}, {2, 2, 2}}, l0);
        migraphx::shape s2{migraphx::shape::int32_type, {2, 2, 2}, {6, 3, 1}};
Scott Thornton's avatar
Scott Thornton committed
45
        EXPECT(p.get_shape() == s2);
Paul's avatar
Paul committed
46
47
        p.compile(migraphx::cpu::target{});
        migraphx::shape sresult{migraphx::shape::int32_type, {2, 2, 2}, {4, 2, 1}};
Scott Thornton's avatar
Scott Thornton committed
48
49
50
51
        auto result           = p.eval({});
        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
52
        EXPECT(migraphx::verify_range(results_vector, gold));
Scott Thornton's avatar
Scott Thornton committed
53
54
        EXPECT(result.get_shape() == sresult);
    }
55
56
}

Paul's avatar
Paul committed
57
TEST_CASE(concat_test)
58
{
Scott Thornton's avatar
Scott Thornton committed
59
    {
Paul's avatar
Paul committed
60
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
61
62
63
64
        std::size_t 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};
Paul's avatar
Paul committed
65
66
67
68
69
70
71
72
        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}};
        auto l0 = p.add_literal(migraphx::literal{s0, data0});
        auto l1 = p.add_literal(migraphx::literal{s1, data1});
        auto l2 = p.add_literal(migraphx::literal{s2, data2});
        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
        p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
73
        auto result           = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
74
        std::vector<int> gold = {0, 1, 2, 3, 4, 10, 5, 6, 7, 8, 9, 20};
Scott Thornton's avatar
Scott Thornton committed
75
        std::vector<int> results_vector(2 * 6);
Scott Thornton's avatar
Scott Thornton committed
76
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
77
78
        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
79
        EXPECT(
Paul's avatar
Paul committed
80
            migraphx::verify_range(result.get_shape().strides(), std::vector<std::size_t>({6, 1})));
Scott Thornton's avatar
Scott Thornton committed
81
82
    }
    {
Paul's avatar
Paul committed
83
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
84
85
86
87
        std::size_t 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};
Paul's avatar
Paul committed
88
89
90
91
92
93
94
95
        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}};
        auto l0 = p.add_literal(migraphx::literal{s0, data0});
        auto l1 = p.add_literal(migraphx::literal{s1, data1});
        auto l2 = p.add_literal(migraphx::literal{s2, data2});
        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
        p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
96
        auto result           = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
97
        std::vector<int> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
Scott Thornton's avatar
Scott Thornton committed
98
        std::vector<int> results_vector(6 * 2);
Scott Thornton's avatar
Scott Thornton committed
99
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
100
101
        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
102
        EXPECT(
Paul's avatar
Paul committed
103
            migraphx::verify_range(result.get_shape().strides(), std::vector<std::size_t>({2, 1})));
Scott Thornton's avatar
Scott Thornton committed
104
    }
105
106
}

107
108
109
110
111
112
113
114
115
116
117
TEST_CASE(gather_test)
{
    {
        migraphx::program p;

        std::vector<float> data(3 * 3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
        auto a0 = p.add_literal(migraphx::literal{s, data});
        migraphx::shape s_indices{migraphx::shape::int32_type, {1, 2}};
        std::vector<int> indices{0, 2};
Shucai Xiao's avatar
Shucai Xiao committed
118
        auto a1  = p.add_literal(migraphx::literal{s_indices, indices});
119
        int axis = 0;
120
        p.add_instruction(migraphx::op::gather{axis}, a0, a1);
121
122
123
        p.compile(migraphx::cpu::target{});
        auto result = p.eval({});
        std::vector<float> res_data(4 * 5);
124
        std::vector<float> golden = {0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
125
126
127
128
129
130
131
132
133
134
135
136
137
        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res_data, golden));
    }

    {
        migraphx::program p;

        std::vector<float> data(3 * 3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
        auto a0 = p.add_literal(migraphx::literal{s, data});
        migraphx::shape s_indices{migraphx::shape::int32_type, {1, 2}};
        std::vector<int> indices{0, 2};
Shucai Xiao's avatar
Shucai Xiao committed
138
        auto a1  = p.add_literal(migraphx::literal{s_indices, indices});
139
        int axis = 1;
140
        p.add_instruction(migraphx::op::gather{axis}, a0, a1);
141
142
143
        p.compile(migraphx::cpu::target{});
        auto result = p.eval({});
        std::vector<float> res_data(4 * 5);
144
        std::vector<float> golden = {0.5f, 2.5f, 3.5f, 5.5f, 6.5f, 8.5f};
145
146
147
        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res_data, golden));
    }
148
149
150
151
152
153
154
155
156
157
158
159

    {
        migraphx::program p;

        std::vector<float> data(3 * 3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
        auto a0 = p.add_literal(migraphx::literal{s, data});
        migraphx::shape s_indices{migraphx::shape::int32_type, {1, 2}};
        std::vector<int> indices{0, 2};
        auto a1  = p.add_literal(migraphx::literal{s_indices, indices});
        int axis = -1;
160
        p.add_instruction(migraphx::op::gather{axis}, a0, a1);
161
162
163
        p.compile(migraphx::cpu::target{});
        auto result = p.eval({});
        std::vector<float> res_data(4 * 5);
164
        std::vector<float> golden = {0.5f, 2.5f, 3.5f, 5.5f, 6.5f, 8.5f};
165
166
167
        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res_data, golden));
    }
168
169
170
171
172
173
174
175
176

    {
        migraphx::program p;

        std::vector<float> data(3 * 3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
        auto a0 = p.add_literal(migraphx::literal{s, data});
        // scalar index
177
        migraphx::shape s_indices{migraphx::shape::int32_type};
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
        std::vector<int> indices{0};
        auto a1  = p.add_literal(migraphx::literal{s_indices, indices});
        int axis = -1;
        p.add_instruction(migraphx::op::gather{axis}, a0, a1);
        p.compile(migraphx::cpu::target{});
        auto result = p.eval({});
        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));
    }

    {
        migraphx::program p;

        std::vector<float> data(3);
        std::iota(data.begin(), data.end(), 0.5);
        migraphx::shape s{migraphx::shape::float_type, {3}};
        auto a0 = p.add_literal(migraphx::literal{s, data});
        // scalar index
198
        migraphx::shape s_indices{migraphx::shape::int32_type};
199
200
201
202
203
204
205
206
207
208
209
        std::vector<int> indices{0};
        auto a1  = p.add_literal(migraphx::literal{s_indices, indices});
        int axis = -1;
        p.add_instruction(migraphx::op::gather{axis}, a0, a1);
        p.compile(migraphx::cpu::target{});
        auto result = p.eval({});
        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));
    }
210
211
}

Paul's avatar
Paul committed
212
TEST_CASE(squeeze_test)
Scott Thornton's avatar
Scott Thornton committed
213
{
214
    {
Paul's avatar
Paul committed
215
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
216
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
217
218
219
220
221
        migraphx::shape s1{migraphx::shape::float_type, {4, 1, 3, 1, 3}};
        migraphx::shape s2{migraphx::shape::float_type, {4, 3, 1, 3}};
        auto l0 = p.add_literal(migraphx::literal{s1, data});
        p.add_instruction(migraphx::op::squeeze{{1}}, l0);
        p.compile(migraphx::cpu::target{});
222
        auto result = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
223
        EXPECT(result.get_shape() == s2);
224
225
    }
    {
Paul's avatar
Paul committed
226
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
227
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
228
229
230
231
232
        migraphx::shape s1{migraphx::shape::float_type, {4, 1, 3, 1, 3}};
        migraphx::shape s2{migraphx::shape::float_type, {4, 1, 3, 3}};
        auto l0 = p.add_literal(migraphx::literal{s1, data});
        p.add_instruction(migraphx::op::squeeze{{3}}, l0);
        p.compile(migraphx::cpu::target{});
233
        auto result = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
234
        EXPECT(result.get_shape() == s2);
235
236
    }
    {
Paul's avatar
Paul committed
237
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
238
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
239
240
241
242
243
        migraphx::shape s1{migraphx::shape::float_type, {4, 1, 3, 1, 3}};
        migraphx::shape s2{migraphx::shape::float_type, {4, 3, 3}};
        auto l0 = p.add_literal(migraphx::literal{s1, data});
        p.add_instruction(migraphx::op::squeeze{}, l0);
        p.compile(migraphx::cpu::target{});
244
        auto result = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
245
        EXPECT(result.get_shape() == s2);
246
247
248
    }
}

Paul's avatar
Paul committed
249
TEST_CASE(unsqueeze_test)
Scott Thornton's avatar
Scott Thornton committed
250
{
251
    {
Paul's avatar
Paul committed
252
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
253
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
254
255
256
257
258
        migraphx::shape s1{migraphx::shape::float_type, {4, 3, 3}};
        migraphx::shape s2{migraphx::shape::float_type, {4, 1, 3, 3}};
        auto l0 = p.add_literal(migraphx::literal{s1, data});
        p.add_instruction(migraphx::op::unsqueeze{{1}}, l0);
        p.compile(migraphx::cpu::target{});
259
        auto result = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
260
261
        EXPECT(result.get_shape() == s2);
    }
262
    {
Paul's avatar
Paul committed
263
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
264
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
265
266
267
268
269
        migraphx::shape s1{migraphx::shape::float_type, {4, 3, 3}};
        migraphx::shape s2{migraphx::shape::float_type, {4, 3, 1, 3}};
        auto l0 = p.add_literal(migraphx::literal{s1, data});
        p.add_instruction(migraphx::op::unsqueeze{{2}}, l0);
        p.compile(migraphx::cpu::target{});
270
        auto result = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
271
272
        EXPECT(result.get_shape() == s2);
    }
273
274
}

Paul's avatar
Paul committed
275
TEST_CASE(globalavgpool_test)
276
{
Paul's avatar
Paul committed
277
278
279
    migraphx::program p;
    auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}};
    auto op    = migraphx::op::pooling{"average"};
280
    auto lens  = s.lens();
Khalique's avatar
Khalique committed
281
    op.lengths = {lens[2], lens[3]};
282
283

    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};
Paul's avatar
Paul committed
284
    auto l0 = p.add_literal(migraphx::literal{s, data});
285
    p.add_instruction(op, l0);
Paul's avatar
Paul committed
286
    p.compile(migraphx::cpu::target{});
287
288
289
290
291
    auto result = p.eval({});

    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
292
    EXPECT(migraphx::verify_range(results_vector, gold));
293
294
}

Paul's avatar
Paul committed
295
TEST_CASE(globalmaxpool_test)
296
{
Paul's avatar
Paul committed
297
298
299
    migraphx::program p;
    auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}};
    auto op    = migraphx::op::pooling{"max"};
300
    auto lens  = s.lens();
Khalique's avatar
Khalique committed
301
    op.lengths = {lens[2], lens[3]};
302
303

    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};
Paul's avatar
Paul committed
304
    auto l0 = p.add_literal(migraphx::literal{s, data});
305
    p.add_instruction(op, l0);
Paul's avatar
Paul committed
306
    p.compile(migraphx::cpu::target{});
307
308
309
310
311
    auto result = p.eval({});

    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
312
    EXPECT(migraphx::verify_range(results_vector, gold));
313
314
}

Paul's avatar
Paul committed
315
TEST_CASE(im2col_3x3_no_pad_identity_test)
Scott Thornton's avatar
Scott Thornton committed
316
317
318
319
320
321
322
323
324
325
326
327
{
    std::size_t f[2]    = {3, 3};
    std::size_t size[2] = {3, 3};
    std::array<std::size_t, 2> padding{{0, 0}};
    std::array<std::size_t, 2> stride{{1, 1}};
    std::array<std::size_t, 2> dilation{{1, 1}};
    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
328
329
330
331
332
333
334
    migraphx::program p;
    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]}};
    auto l_image   = p.add_literal(migraphx::literal{s_image, input});
    auto l_weights = p.add_literal(migraphx::literal{s_weights, weights});
    p.add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
335
336
337
338
339
340
    auto result = p.eval({});

    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
341
    EXPECT(migraphx::verify_range(results_vector, input));
Scott Thornton's avatar
Scott Thornton committed
342
343
}

Paul's avatar
Paul committed
344
TEST_CASE(im2col_3x3_no_pad_test)
Scott Thornton's avatar
Scott Thornton committed
345
346
347
348
349
350
351
352
353
354
355
356
{
    std::size_t f[2]    = {3, 3};
    std::size_t size[2] = {4, 4};
    std::array<std::size_t, 2> padding{{0, 0}};
    std::array<std::size_t, 2> stride{{1, 1}};
    std::array<std::size_t, 2> dilation{{1, 1}};
    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
357
358
359
360
361
362
363
    migraphx::program p;
    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]}};
    auto l_image   = p.add_literal(migraphx::literal{s_image, input});
    auto l_weights = p.add_literal(migraphx::literal{s_weights, weights});
    p.add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
364
365
366
367
368
369
370
371
372
    auto result = p.eval({});

    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
373
    EXPECT(migraphx::verify_range(results_vector, correct));
Scott Thornton's avatar
Scott Thornton committed
374
375
}

Paul's avatar
Paul committed
376
TEST_CASE(im2col_3x3_stride_2_no_pad_test)
Scott Thornton's avatar
Scott Thornton committed
377
378
379
380
381
382
383
384
385
386
387
388
{
    std::size_t f[2]    = {3, 3};
    std::size_t size[2] = {6, 6};
    std::array<std::size_t, 2> padding{{0, 0}};
    std::array<std::size_t, 2> stride{{2, 2}};
    std::array<std::size_t, 2> dilation{{1, 1}};
    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
389
390
391
392
393
394
395
    migraphx::program p;
    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]}};
    auto l_image   = p.add_literal(migraphx::literal{s_image, input});
    auto l_weights = p.add_literal(migraphx::literal{s_weights, weights});
    p.add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
396
397
398
399
400
401
402
403
404
405
    auto result = p.eval({});

    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
406
    EXPECT(migraphx::verify_range(results_vector, correct));
Scott Thornton's avatar
Scott Thornton committed
407
408
}

Paul's avatar
Paul committed
409
TEST_CASE(im2col_3x3_with_padding_test)
Scott Thornton's avatar
Scott Thornton committed
410
411
412
413
414
415
416
417
418
419
420
421
{
    std::size_t f[2]    = {3, 3};
    std::size_t size[2] = {2, 2};
    std::array<std::size_t, 2> padding{{1, 1}};
    std::array<std::size_t, 2> stride{{1, 1}};
    std::array<std::size_t, 2> dilation{{1, 1}};
    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
422
423
424
425
426
427
428
    migraphx::program p;
    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]}};
    auto l_image   = p.add_literal(migraphx::literal{s_image, input});
    auto l_weights = p.add_literal(migraphx::literal{s_weights, weights});
    p.add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
429
430
431
432
433
434
435
436
437
    auto result = p.eval({});

    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
438
    EXPECT(migraphx::verify_range(results_vector, correct));
Scott Thornton's avatar
Scott Thornton committed
439
440
}

Paul's avatar
Paul committed
441
TEST_CASE(batch_norm_inference_test)
442
{
Paul's avatar
Paul committed
443
    migraphx::program p;
Paul's avatar
Paul committed
444
445
446
447
448
449
    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
450
    const float variance_val = 4.0;
Paul's avatar
Paul committed
451
452
    const float scale_val    = 2.0f;
    const float bias_val     = 1.0f;
Aditya Atluri's avatar
Aditya Atluri committed
453
454
    const float output_val = scale_val * (x_val - mean_val) / (std::sqrt(variance_val)) + bias_val;

Paul's avatar
Paul committed
455
456
    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
457
458
459
460
461
462
463
464
465
466
467
468
    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);

Paul's avatar
Paul committed
469
470
471
472
473
    auto x        = p.add_literal(migraphx::literal{s, x_data});
    auto scale    = p.add_literal(migraphx::literal{vars, scale_data});
    auto bias     = p.add_literal(migraphx::literal{vars, bias_data});
    auto mean     = p.add_literal(migraphx::literal{vars, mean_data});
    auto variance = p.add_literal(migraphx::literal{vars, variance_data});
Aditya Atluri's avatar
Aditya Atluri committed
474

Paul's avatar
Paul committed
475
476
    p.add_instruction(migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
    p.compile(migraphx::cpu::target{});
477
    auto result = p.eval({});
Aditya Atluri's avatar
Aditya Atluri committed
478
479
480
481

    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
482
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
Aditya Atluri's avatar
Aditya Atluri committed
483

Paul's avatar
Paul committed
484
    EXPECT(migraphx::verify_range(result_vector, gold));
485
486
}

Paul's avatar
Paul committed
487
TEST_CASE(im2col_3x3_with_channels_identity_test)
Scott Thornton's avatar
Scott Thornton committed
488
489
490
491
492
493
494
495
496
497
498
499
{
    std::size_t f[2]    = {3, 3};
    std::size_t size[2] = {3, 3};
    std::array<std::size_t, 2> padding{{0, 0}};
    std::array<std::size_t, 2> stride{{1, 1}};
    std::array<std::size_t, 2> dilation{{1, 1}};
    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
500
501
502
503
504
505
506
    migraphx::program p;
    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]}};
    auto l_image   = p.add_literal(migraphx::literal{s_image, input});
    auto l_weights = p.add_literal(migraphx::literal{s_weights, weights});
    p.add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
507
508
509
510
511
512
    auto result = p.eval({});

    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
513
    EXPECT(migraphx::verify_range(results_vector, input));
Scott Thornton's avatar
Scott Thornton committed
514
515
}

Paul's avatar
Paul committed
516
TEST_CASE(exp_test)
517
{
Paul's avatar
Paul committed
518
519
520
521
522
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
    p.add_instruction(migraphx::op::exp{}, l);
    p.compile(migraphx::cpu::target{});
523
524
    auto result = p.eval({});
    std::vector<float> results_vector(3);
525
526
    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
527
    EXPECT(migraphx::verify_range(results_vector, gold));
528
529
}

Shucai Xiao's avatar
Shucai Xiao committed
530
531
532
533
534
535
536
537
538
539
540
541
542
543
TEST_CASE(erf_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {4}};
    auto l = p.add_literal(migraphx::literal{s, {0.73785057,  1.58165966, -0.43597795, -0.01677432}});
    p.add_instruction(migraphx::op::erf{}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    std::vector<float> gold = {0.70327317,  0.97470088, -0.46247893, -0.01892602};
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
544
545
546
547
548
549
550
551
552
553
554
555
556
557
TEST_CASE(log_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l = p.add_literal(migraphx::literal{s, {1, 2, 3}});
    p.add_instruction(migraphx::op::log{}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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));
}

Paul's avatar
Paul committed
558
TEST_CASE(sin_test)
559
{
Paul's avatar
Paul committed
560
561
562
563
564
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
    p.add_instruction(migraphx::op::sin{}, l);
    p.compile(migraphx::cpu::target{});
565
566
    auto result = p.eval({});
    std::vector<float> results_vector(3);
567
568
    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
569
    EXPECT(migraphx::verify_range(results_vector, gold));
570
571
}

Paul's avatar
Paul committed
572
TEST_CASE(cos_test)
573
{
Paul's avatar
Paul committed
574
575
576
577
578
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
    p.add_instruction(migraphx::op::cos{}, l);
    p.compile(migraphx::cpu::target{});
579
580
    auto result = p.eval({});
    std::vector<float> results_vector(3);
581
582
    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
583
    EXPECT(migraphx::verify_range(results_vector, gold));
584
585
}

Paul's avatar
Paul committed
586
TEST_CASE(tan_test)
587
{
Paul's avatar
Paul committed
588
589
590
591
592
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
    p.add_instruction(migraphx::op::tan{}, l);
    p.compile(migraphx::cpu::target{});
593
594
    auto result = p.eval({});
    std::vector<float> results_vector(3);
595
596
    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
597
    EXPECT(migraphx::verify_range(results_vector, gold));
598
599
}

600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
TEST_CASE(asin_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    std::vector<float> data{-0.5f, 0.0f, 0.9f};
    auto l = p.add_literal(migraphx::literal{s, data});
    p.add_instruction(migraphx::op::asin{}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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;
    migraphx::shape s{migraphx::shape::double_type, {3}};
    std::vector<float> data{-0.8f, 0.0f, 1.0f};
    auto l = p.add_literal(migraphx::literal{s, data});
    p.add_instruction(migraphx::op::acos{}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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;
    migraphx::shape s{migraphx::shape::double_type, {3}};
    auto l = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
    p.add_instruction(migraphx::op::atan{}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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));
}

Paul's avatar
Paul committed
644
TEST_CASE(add_test)
645
{
Paul's avatar
Paul committed
646
647
648
649
650
651
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l1 = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
    auto l2 = p.add_literal(migraphx::literal{s, {1, 2, 3}});
    p.add_instruction(migraphx::op::add{}, l1, l2);
    p.compile(migraphx::cpu::target{});
652
653
654
655
    auto result = p.eval({});
    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
656
    EXPECT(migraphx::verify_range(results_vector, gold));
657
658
}

Paul's avatar
Paul committed
659
TEST_CASE(broadcast_test)
660
{
Paul's avatar
Paul committed
661
662
    migraphx::program p;
    migraphx::shape a_shape{migraphx::shape::int32_type, {2, 2}};
663
    std::vector<int32_t> a_data{0, 0, 0, 0};
Paul's avatar
Paul committed
664
    migraphx::shape b_shape{migraphx::shape::int32_type, {2}};
665
    std::vector<int32_t> b_data{-2, -3};
666
    uint64_t axis = 0;
Paul's avatar
Paul committed
667
668
    auto l1       = p.add_literal(migraphx::literal{a_shape, a_data});
    auto l2       = p.add_literal(migraphx::literal{b_shape, b_data});
669
    p.add_instruction(migraphx::op::broadcast{axis, l1->get_shape().lens()}, l2);
Paul's avatar
Paul committed
670
    p.compile(migraphx::cpu::target{});
671
    auto result = p.eval({});
Paul's avatar
Paul committed
672
    auto output = result.get<int32_t>();
Paul's avatar
Paul committed
673
674
675
676
    EXPECT(output(0, 0) == -2);
    EXPECT(output(0, 1) == -2);
    EXPECT(output(1, 0) == -3);
    EXPECT(output(1, 1) == -3);
677
}
Paul's avatar
Paul committed
678
TEST_CASE(add_broadcast_test)
679
{
680
    {
Paul's avatar
Paul committed
681
682
        migraphx::program p;
        migraphx::shape a_shape{migraphx::shape::float_type, {2, 2, 3}};
683
        std::vector<float> a_data{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
Paul's avatar
Paul committed
684
        migraphx::shape b_shape{migraphx::shape::float_type, {2, 2}};
685
686
        std::vector<float> b_data{0, -1, -2, -3};
        uint64_t axis = 0;
Paul's avatar
Paul committed
687
688
        auto l1       = p.add_literal(migraphx::literal{a_shape, a_data});
        auto l2       = p.add_literal(migraphx::literal{b_shape, b_data});
Shucai Xiao's avatar
Shucai Xiao committed
689
        auto l3 = p.add_instruction(migraphx::op::broadcast{axis, l1->get_shape().lens()}, l2);
Paul's avatar
Paul committed
690
691
        p.add_instruction(migraphx::op::add{}, l1, l3);
        p.compile(migraphx::cpu::target{});
692
693
694
695
696
        auto result = p.eval({});
        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
697
        EXPECT(migraphx::verify_range(results_vector, gold));
698
699
    }
    {
Paul's avatar
Paul committed
700
701
        migraphx::program p;
        migraphx::shape a_shape{migraphx::shape::float_type, {2, 2, 3}};
702
        std::vector<float> a_data{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
Paul's avatar
Paul committed
703
        migraphx::shape b_shape{migraphx::shape::float_type, {2, 2, 1}};
704
        std::vector<float> b_data{0, -1, -2, -3};
Paul's avatar
Paul committed
705
706
707
708
709
710
        auto l1 = p.add_literal(migraphx::literal{a_shape, a_data});
        auto l2 = p.add_literal(migraphx::literal{b_shape, b_data});
        auto l3 = p.add_instruction(migraphx::op::multibroadcast{{2, 2, 3}}, l1);
        auto l4 = p.add_instruction(migraphx::op::multibroadcast{{2, 2, 3}}, l2);
        p.add_instruction(migraphx::op::add{}, l3, l4);
        p.compile(migraphx::cpu::target{});
711
712
713
714
715
        auto result = p.eval({});
        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
716
        EXPECT(migraphx::verify_range(results_vector, gold));
717
    }
718
719
}

Paul's avatar
Paul committed
720
TEST_CASE(sub_test)
721
{
Paul's avatar
Paul committed
722
723
724
725
726
727
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l1 = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
    auto l2 = p.add_literal(migraphx::literal{s, {1, 2, 3}});
    p.add_instruction(migraphx::op::sub{}, l1, l2);
    p.compile(migraphx::cpu::target{});
728
729
730
731
    auto result = p.eval({});
    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
732
    EXPECT(migraphx::verify_range(results_vector, gold));
733
734
}

Paul's avatar
Paul committed
735
TEST_CASE(mul_test)
736
{
Paul's avatar
Paul committed
737
738
739
740
741
742
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l1 = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
    auto l2 = p.add_literal(migraphx::literal{s, {1, 2, 3}});
    p.add_instruction(migraphx::op::mul{}, l1, l2);
    p.compile(migraphx::cpu::target{});
743
744
745
746
    auto result = p.eval({});
    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
747
    EXPECT(migraphx::verify_range(results_vector, gold));
748
749
}

Paul's avatar
Paul committed
750
TEST_CASE(div_test)
751
{
Paul's avatar
Paul committed
752
753
754
755
756
757
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l1 = p.add_literal(migraphx::literal{s, {-1.0f, 0.5f, 1.0f}});
    auto l2 = p.add_literal(migraphx::literal{s, {1.0f, 2.0f, 4.0f}});
    p.add_instruction(migraphx::op::div{}, l1, l2);
    p.compile(migraphx::cpu::target{});
758
759
760
761
    auto result = p.eval({});
    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
762
    EXPECT(migraphx::verify_range(results_vector, gold));
763
764
}

Paul's avatar
Paul committed
765
TEST_CASE(relu_test)
Khalique's avatar
Khalique committed
766
{
Paul's avatar
Paul committed
767
768
769
770
771
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l = p.add_literal(migraphx::literal{s, {-1.f, 0.f, 1.f}});
    p.add_instruction(migraphx::op::relu{}, l);
    p.compile(migraphx::cpu::target{});
Khalique's avatar
Khalique committed
772
773
774
775
    auto result = p.eval({});
    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
776
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
777
778
}

Paul's avatar
Paul committed
779
TEST_CASE(leaky_relu_test)
Khalique's avatar
Khalique committed
780
{
Paul's avatar
Paul committed
781
782
783
784
785
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l = p.add_literal(migraphx::literal{s, {-1.f, 0.f, 1.f}});
    p.add_instruction(migraphx::op::leaky_relu{0.01}, l);
    p.compile(migraphx::cpu::target{});
Khalique's avatar
Khalique committed
786
787
788
789
    auto result = p.eval({});
    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
790
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
791
792
}

Khalique's avatar
Khalique committed
793
TEST_CASE(lrn_test)
Khalique's avatar
Khalique committed
794
{
Khalique's avatar
Khalique committed
795
796
797
798
799
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {1, 5, 1, 1}};
    auto l = p.add_literal(migraphx::literal{s, {-2.0f, 1.0f, 0.f, 1.0f, 2.0f}});
    p.add_instruction(migraphx::op::lrn{0.0001, 0.75, 1, 5}, l);
    p.compile(migraphx::cpu::target{});
Khalique's avatar
Khalique committed
800
801
802
    auto result = p.eval({});
    std::vector<float> results_vector(5);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Khalique's avatar
Khalique committed
803
    std::vector<float> gold = {-2 / 1.000075, 1 / 1.00009, 0 / 1.000145, 1 / 1.00009, 2 / 1.000075};
Khalique's avatar
Khalique committed
804
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
805
806
}

Paul's avatar
Paul committed
807
TEST_CASE(imagescaler_test)
Khalique's avatar
Khalique committed
808
{
Paul's avatar
Paul committed
809
810
811
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {1, 3, 2, 2}};
    auto img           = p.add_literal(migraphx::literal{s,
Paul's avatar
Paul committed
812
813
814
815
816
817
818
819
820
821
822
823
824
825
                                               {0.2,
                                                0.3,
                                                0.5,
                                                0.4,

                                                0.7,
                                                0.8,
                                                0.1,
                                                0.9,

                                                0.15,
                                                0.25,
                                                0.35,
                                                0.45}});
Khalique's avatar
Khalique committed
826
    auto scale_val     = p.add_literal(2.f);
827
    auto scaled_tensor = p.add_instruction(migraphx::op::scalar{s.lens()}, scale_val);
Paul's avatar
Paul committed
828
    auto img_scaled    = p.add_instruction(migraphx::op::mul{}, img, scaled_tensor);
Khalique's avatar
Khalique committed
829
    auto bias_vals     = p.add_literal(
Paul's avatar
Paul committed
830
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
831
    auto bias_bcast = p.add_instruction(migraphx::op::broadcast{1, s.lens()}, bias_vals);
Paul's avatar
Paul committed
832
833
    p.add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);
    p.compile(migraphx::cpu::target{});
Khalique's avatar
Khalique committed
834
835
836
    auto result = p.eval({});
    std::vector<float> results_vector(12);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Khalique's avatar
Khalique committed
837
838
839
840
841
842
843
844
845
846
847
848
849
850
    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
851
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
852
853
}

Paul's avatar
Paul committed
854
TEST_CASE(reshape_test)
855
{
Paul's avatar
Paul committed
856
    migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
857
858
859
    std::vector<float> data(24);
    std::iota(data.begin(), data.end(), -3);
    {
Paul's avatar
Paul committed
860
861
        migraphx::program p;
        auto l                         = p.add_literal(migraphx::literal{a_shape, data});
862
        std::vector<int64_t> new_shape = {8, 3, 1, 1};
Paul's avatar
Paul committed
863
864
        p.add_instruction(migraphx::op::reshape{new_shape}, l);
        p.compile(migraphx::cpu::target{});
865
866
        auto result = p.eval({});
        std::vector<float> results_vector(3);
867
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
868
        EXPECT(migraphx::verify_range(results_vector, data));
869
870
    }
    {
Paul's avatar
Paul committed
871
872
        migraphx::program p;
        auto l                         = p.add_literal(migraphx::literal{a_shape, data});
873
        std::vector<int64_t> new_shape = {1, 3, 4, 2};
Paul's avatar
Paul committed
874
875
        p.add_instruction(migraphx::op::reshape{new_shape}, l);
        p.compile(migraphx::cpu::target{});
876
877
        auto result = p.eval({});
        std::vector<float> results_vector(3);
878
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
879
        EXPECT(migraphx::verify_range(results_vector, data));
880
881
    }
    {
Paul's avatar
Paul committed
882
883
        migraphx::program p;
        auto l                         = p.add_literal(migraphx::literal{a_shape, data});
884
        std::vector<int64_t> new_shape = {1, 3, 4, 2};
Paul's avatar
Paul committed
885
886
        p.add_instruction(migraphx::op::reshape{new_shape}, l);
        p.compile(migraphx::cpu::target{});
887
888
        auto result = p.eval({});
        std::vector<float> results_vector(3);
889
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
890
        EXPECT(migraphx::verify_range(results_vector, data));
891
892
893
    }
}

Paul's avatar
Paul committed
894
TEST_CASE(maxpool_test)
895
{
Paul's avatar
Paul committed
896
    migraphx::program p;
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
    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
935
936
937
938
    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 6, 6}};
    auto al = p.add_literal(migraphx::literal{a_shape, a});
    p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{3, 2}}}, al);
    p.compile(migraphx::cpu::target{});
939
    auto result = p.eval({});
Paul's avatar
Paul committed
940
    // std::cout << result.get_shape() << std::endl;
941
942
    std::vector<float> results_vector(36);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
943
    EXPECT(migraphx::verify_range(results_vector, c));
944
945
}

Khalique's avatar
Khalique committed
946
947
948
TEST_CASE(softmax_simple_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
949
950
    std::vector<float> a = {0.25, 0.75};
    std::vector<float> s = {0.377541, 0.622459};
Khalique's avatar
Khalique committed
951
952
    migraphx::shape a_shape{migraphx::shape::float_type, {1, 2}};
    auto al = p.add_literal(migraphx::literal{a_shape, a});
953
    p.add_instruction(migraphx::op::softmax{1}, al);
Khalique's avatar
Khalique committed
954
955
956
957
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    std::vector<float> results_vector(2);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Shucai Xiao's avatar
Shucai Xiao committed
958
    for(auto v : results_vector)
959
960
        std::cout << v << "\t";
    std::cout << std::endl;
Khalique's avatar
Khalique committed
961
962
963
    EXPECT(migraphx::verify_range(results_vector, s));
}

Paul's avatar
Paul committed
964
TEST_CASE(softmax_test)
965
{
Paul's avatar
Paul committed
966
    migraphx::program p;
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
    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
1013
1014
1015
1016
    migraphx::shape a_shape{migraphx::shape::float_type, {5, 3, 4, 2}};
    auto al = p.add_literal(migraphx::literal{a_shape, a});
    p.add_instruction(migraphx::op::softmax{}, al);
    p.compile(migraphx::cpu::target{});
1017
1018
    auto result = p.eval({});
    std::vector<float> results_vector(120);
1019
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
1020
    EXPECT(migraphx::verify_range(results_vector, s));
Scott Thornton's avatar
Scott Thornton committed
1021
1022
}

1023
1024
1025
1026
TEST_CASE(logsoftmax_test_axis_0)
{
    migraphx::program p;
    std::vector<float> a = {
Shucai Xiao's avatar
Shucai Xiao committed
1027
1028
1029
1030
1031
1032
1033
1034
        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};
1035
1036

    std::vector<float> s = {
Shucai Xiao's avatar
Shucai Xiao committed
1037
1038
1039
1040
1041
1042
        -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,
1043
        -0.720302, -0.460499, -0.469651, -0.556740, -0.554628, -0.551582};
1044
1045

    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
Shucai Xiao's avatar
Shucai Xiao committed
1046
    auto al  = p.add_literal(migraphx::literal{a_shape, a});
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
    int axis = 0;
    p.add_instruction(migraphx::op::logsoftmax{axis}, al);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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;
    std::vector<float> a = {
Shucai Xiao's avatar
Shucai Xiao committed
1060
1061
1062
1063
1064
1065
1066
1067
        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};
1068
1069

    std::vector<float> s = {
Shucai Xiao's avatar
Shucai Xiao committed
1070
1071
1072
1073
1074
1075
        -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,
1076
        -1.179017, -3.312239, -1.286363, -1.586076, -0.345100, -0.824173};
1077
1078

    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
Shucai Xiao's avatar
Shucai Xiao committed
1079
    auto al  = p.add_literal(migraphx::literal{a_shape, a});
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
    int axis = 1;
    p.add_instruction(migraphx::op::logsoftmax{axis}, al);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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;
    std::vector<float> a = {
Shucai Xiao's avatar
Shucai Xiao committed
1093
1094
1095
1096
1097
1098
1099
1100
        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};
1101
1102

    std::vector<float> s = {
Shucai Xiao's avatar
Shucai Xiao committed
1103
1104
1105
1106
1107
1108
        -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,
1109
        -1.948685, -3.671233, -0.875521, -3.111952, -1.905644, -1.6076011};
1110
1111

    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
Shucai Xiao's avatar
Shucai Xiao committed
1112
    auto al  = p.add_literal(migraphx::literal{a_shape, a});
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
    int axis = 2;
    p.add_instruction(migraphx::op::logsoftmax{axis}, al);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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;
    std::vector<float> a = {
Shucai Xiao's avatar
Shucai Xiao committed
1126
1127
1128
1129
1130
1131
1132
1133
        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};
1134
1135

    std::vector<float> s = {
Shucai Xiao's avatar
Shucai Xiao committed
1136
1137
1138
1139
1140
1141
        -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,
1142
        -1.487672, -2.417791, -0.378360, -2.568531, -0.569794, -1.028032};
1143
1144

    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
Shucai Xiao's avatar
Shucai Xiao committed
1145
    auto al  = p.add_literal(migraphx::literal{a_shape, a});
1146
1147
1148
1149
1150
1151
1152
1153
1154
    int axis = 3;
    p.add_instruction(migraphx::op::logsoftmax{axis}, al);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    std::vector<float> results_vector;
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    EXPECT(migraphx::verify_range(results_vector, s));
}

Paul's avatar
Paul committed
1155
TEST_CASE(conv2d_test)
1156
{
Paul's avatar
Paul committed
1157
    migraphx::program p;
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
    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
1202
                            -0.46427044};
Paul's avatar
Paul committed
1203
1204
    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
    auto al = p.add_literal(migraphx::literal{a_shape, a});
Scott Thornton's avatar
Scott Thornton committed
1205

Paul's avatar
Paul committed
1206
1207
    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
    auto cl = p.add_literal(migraphx::literal{c_shape, c});
Scott Thornton's avatar
Scott Thornton committed
1208

Paul's avatar
Paul committed
1209
1210
    p.add_instruction(migraphx::op::convolution{}, al, cl);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
1211
1212
1213
    auto result = p.eval({});

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

Paul's avatar
Paul committed
1218
TEST_CASE(conv2d_padding_test)
1219
{
Paul's avatar
Paul committed
1220
    migraphx::program p;
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
    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
1259
1260
    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
    auto al = p.add_literal(migraphx::literal{a_shape, a});
Scott Thornton's avatar
Scott Thornton committed
1261

Paul's avatar
Paul committed
1262
1263
    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
    auto cl = p.add_literal(migraphx::literal{c_shape, c});
Scott Thornton's avatar
Scott Thornton committed
1264

Paul's avatar
Paul committed
1265
1266
    p.add_instruction(migraphx::op::convolution{{{1, 1}}, {{1, 1}}}, al, cl);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
1267
1268
1269
    auto result = p.eval({});

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

Paul's avatar
Paul committed
1274
TEST_CASE(conv2d_padding_stride_test)
1275
{
Paul's avatar
Paul committed
1276
    migraphx::program p;
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
    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
1320
1321
    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
    auto al = p.add_literal(migraphx::literal{a_shape, a});
Scott Thornton's avatar
Scott Thornton committed
1322

Paul's avatar
Paul committed
1323
1324
    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
    auto cl = p.add_literal(migraphx::literal{c_shape, c});
Scott Thornton's avatar
Scott Thornton committed
1325

Paul's avatar
Paul committed
1326
1327
    p.add_instruction(migraphx::op::convolution{{{1, 1}}, {{2, 2}}}, al, cl);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
1328
1329
1330
    auto result = p.eval({});

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

Paul's avatar
Paul committed
1335
TEST_CASE(transpose_test)
1336
{
Paul's avatar
Paul committed
1337
    migraphx::shape a_shape{migraphx::shape::float_type, {1, 2, 2, 3}};
1338
1339
1340
    std::vector<float> data(12);
    std::iota(data.begin(), data.end(), 0);

1341
    {
Paul's avatar
Paul committed
1342
1343
        migraphx::program p;
        auto l                    = p.add_literal(migraphx::literal{a_shape, data});
Paul's avatar
Paul committed
1344
        std::vector<int64_t> perm = {0, 3, 1, 2};
Paul's avatar
Paul committed
1345
1346
        p.add_instruction(migraphx::op::transpose{perm}, l);
        p.compile(migraphx::cpu::target{});
1347
        auto result = p.eval({});
1348

Paul's avatar
Paul committed
1349
        result.visit([&](auto output) {
Paul's avatar
Paul committed
1350
            std::vector<size_t> new_lens = {1, 3, 2, 2};
Paul's avatar
Paul committed
1351
1352
            EXPECT(bool{output.get_shape().lens() == new_lens});
        });
1353
1354
    }
    {
Paul's avatar
Paul committed
1355
1356
        migraphx::program p;
        auto l                    = p.add_literal(migraphx::literal{a_shape, data});
Paul's avatar
Paul committed
1357
        std::vector<int64_t> perm = {0, 3, 1, 2};
Paul's avatar
Paul committed
1358
1359
1360
        auto result               = p.add_instruction(migraphx::op::transpose{perm}, l);
        p.add_instruction(migraphx::op::contiguous{}, result);
        p.compile(migraphx::cpu::target{});
1361
1362
1363
1364
1365
        auto result2 = p.eval({});

        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
1366
        EXPECT(migraphx::verify_range(results_vector, gold));
1367
    }
1368
1369
}

Paul's avatar
Paul committed
1370
TEST_CASE(contiguous_test)
Paul's avatar
Paul committed
1371
{
Paul's avatar
Paul committed
1372
    migraphx::shape a_shape{migraphx::shape::float_type, {1, 3, 2, 2}, {12, 1, 6, 3}};
1373
1374
1375
    std::vector<float> data(12);
    std::iota(data.begin(), data.end(), 0);

Paul's avatar
Paul committed
1376
1377
1378
1379
    migraphx::program p;
    auto l = p.add_literal(migraphx::literal{a_shape, data});
    p.add_instruction(migraphx::op::contiguous{}, l);
    p.compile(migraphx::cpu::target{});
1380
1381
1382
    auto result = p.eval({});

    std::vector<float> results_vector(12);
1383
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
1384
1385
    std::vector<size_t> new_lens    = {1, 3, 2, 2};
    std::vector<size_t> new_strides = {12, 1, 6, 3};
Paul's avatar
Paul committed
1386
    std::vector<float> gold         = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
Paul's avatar
Paul committed
1387
    EXPECT(migraphx::verify_range(results_vector, gold));
1388
1389
}

Khalique's avatar
Khalique committed
1390
1391
TEST_CASE(identity_test)
{
Khalique's avatar
Khalique committed
1392
1393
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
Khalique's avatar
Khalique committed
1394
    std::vector<int> data{1, 2, 3, 4};
Khalique's avatar
Khalique committed
1395
1396
1397
    auto l = p.add_literal(migraphx::literal{s, data});
    p.add_instruction(migraphx::op::identity{}, l);
    p.compile(migraphx::cpu::target{});
Khalique's avatar
Khalique committed
1398
1399
1400
1401
1402
1403
    auto result = p.eval({});
    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
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
TEST_CASE(abs_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
    auto l = p.add_literal(migraphx::literal{s, {-1, 2, -3, 4}});
    p.add_instruction(migraphx::op::abs{}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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;
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
    auto l = p.add_literal(migraphx::literal{s, {-1, 2, -3, 4}});
    p.add_instruction(migraphx::op::sigmoid{}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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));
}

1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
TEST_CASE(sinh_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
    auto l = p.add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
    p.add_instruction(migraphx::op::sinh{}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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;
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
    auto l = p.add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
    p.add_instruction(migraphx::op::cosh{}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
TEST_CASE(tanh_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
    auto l = p.add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
    p.add_instruction(migraphx::op::tanh{}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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;
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
Khalique's avatar
Khalique committed
1478
    auto l      = p.add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
Khalique's avatar
Khalique committed
1479
1480
1481
1482
1483
1484
    float alpha = 0.5;
    p.add_instruction(migraphx::op::elu{alpha}, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    std::vector<float> results_vector(4);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Khalique's avatar
Khalique committed
1485
    std::vector<float> gold{elu(alpha, -1), elu(alpha, 2), elu(alpha, -3), elu(alpha, 4)};
Khalique's avatar
Khalique committed
1486
1487
1488
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Khalique's avatar
Khalique committed
1489
1490
1491
1492
TEST_CASE(max_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
Khalique's avatar
Khalique committed
1493
1494
1495
    auto l0       = p.add_literal(migraphx::literal{s, {1, 4, 3}});
    auto l1       = p.add_literal(migraphx::literal{s, {2, 8, 6}});
    auto l2       = p.add_literal(migraphx::literal{s, {7, 5, 9}});
Khalique's avatar
Khalique committed
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
    auto curr_max = p.add_instruction(migraphx::op::max{}, l0, l1);
    p.add_instruction(migraphx::op::max{}, curr_max, l2);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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;
    migraphx::shape s{migraphx::shape::float_type, {3}};
Khalique's avatar
Khalique committed
1510
1511
1512
    auto l0       = p.add_literal(migraphx::literal{s, {1, 4, 3}});
    auto l1       = p.add_literal(migraphx::literal{s, {2, 8, 6}});
    auto l2       = p.add_literal(migraphx::literal{s, {7, 5, 9}});
Khalique's avatar
Khalique committed
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
    auto curr_min = p.add_instruction(migraphx::op::min{}, l0, l1);
    p.add_instruction(migraphx::op::min{}, curr_min, l2);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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));
}

1523
1524
1525
TEST_CASE(pad_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
1526
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
1527
    auto l0 = p.add_literal(migraphx::literal{s, {1, 2, 3, 4}});
Khalique's avatar
Khalique committed
1528
    p.add_instruction(migraphx::op::pad{{1, 1, 1, 1}}, l0);
1529
1530
1531
1532
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    std::vector<float> results_vector(16);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Khalique's avatar
Khalique committed
1533
    std::vector<float> gold{0, 0, 0, 0, 0, 1, 2, 0, 0, 3, 4, 0, 0, 0, 0, 0};
1534
1535
1536
    EXPECT(migraphx::verify_range(results_vector, gold));
}

1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
TEST_CASE(fp16_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::half_type, {1}};
    migraphx::half a{1.5};
    migraphx::half b{2.5};
    migraphx::half c{4.0};
    auto l0 = p.add_literal(migraphx::literal{s, {a}});
    auto l1 = p.add_literal(migraphx::literal{s, {b}});
    p.add_instruction(migraphx::op::add{}, l0, l1);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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));
}

1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
TEST_CASE(fp32_fp16_test)
{
    auto create_program = [] {
        migraphx::program p;
        migraphx::shape s{migraphx::shape::float_type, {2, 3}};
        std::vector<float> data(2 * 3);
        std::iota(data.begin(), data.end(), 1.0f);
        auto l1 = p.add_literal(migraphx::literal(s, data));
        auto l2 = p.add_literal(migraphx::literal(s, data));
        p.add_instruction(migraphx::op::add{}, l1, l2);
        return p;
    };

Shucai Xiao's avatar
Shucai Xiao committed
1568
    auto test_case = [&](std::vector<std::string>&& op_names) {
1569
        std::vector<float> gold_res = {2.0, 4.0, 6.0, 8.0, 10.0, 12.0};
Shucai Xiao's avatar
Shucai Xiao committed
1570
        auto p                      = create_program();
1571
        migraphx::quantize(p, op_names);
1572
1573
1574
1575
1576
        p.compile(migraphx::cpu::target{});
        auto result = p.eval({});
        std::vector<float> res;
        result.visit([&](auto output) { res.assign(output.begin(), output.end()); });
        EXPECT(migraphx::verify_range(res, gold_res));
1577
    };
1578

1579
1580
    test_case({"all"});
    test_case({"add"});
1581
1582
}

Khalique's avatar
Khalique committed
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
TEST_CASE(clip_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
    auto l = p.add_literal(migraphx::literal{s, {-1.0, 0.0, 10.0}});
    migraphx::op::clip op;
    op.max_val = 6.0;
    op.min_val = 0.0;
    p.add_instruction(op, l);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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));
}

Paul's avatar
Paul committed
1600
1601
1602
1603
1604
TEST_CASE(reduce_sum_test0)
{
    migraphx::program p;
    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}};
Paul's avatar
Paul committed
1605
    auto l0    = p.add_literal(input);
Paul's avatar
Paul committed
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
    p.add_instruction(migraphx::op::reduce_sum{{0}}, l0);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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);
}

TEST_CASE(reduce_sum_test1)
{
    migraphx::program p;
    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}};
Paul's avatar
Paul committed
1620
    auto l0    = p.add_literal(input);
Paul's avatar
Paul committed
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
    p.add_instruction(migraphx::op::reduce_sum{{1}}, l0);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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);
}

TEST_CASE(reduce_sum_test2)
{
    migraphx::program p;
    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}};
Paul's avatar
Paul committed
1635
    auto l0    = p.add_literal(input);
Paul's avatar
Paul committed
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
    p.add_instruction(migraphx::op::reduce_sum{{2}}, l0);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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);
}

TEST_CASE(reduce_sum_test02)
{
    migraphx::program p;
    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}};
Paul's avatar
Paul committed
1650
    auto l0    = p.add_literal(input);
Paul's avatar
Paul committed
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
    p.add_instruction(migraphx::op::reduce_sum{{0, 2}}, l0);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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);
}

TEST_CASE(reduce_sum_test12)
{
    migraphx::program p;
    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}};
Paul's avatar
Paul committed
1665
    auto l0    = p.add_literal(input);
Paul's avatar
Paul committed
1666
1667
1668
1669
1670
1671
1672
1673
1674
    p.add_instruction(migraphx::op::reduce_sum{{1, 2}}, l0);
    p.compile(migraphx::cpu::target{});
    auto result = p.eval({});
    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);
}

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