"...targets/git@developer.sourcefind.cn:gaoqiong/migraphx.git" did not exist on "cb722cf9e3591355c68495921b89148d08c015fc"
cpu_ops_test.cpp 57.6 KB
Newer Older
1
2
#include <iostream>
#include <vector>
Paul's avatar
Paul committed
3
4
5
6
7
#include <migraphx/literal.hpp>
#include <migraphx/operators.hpp>
#include <migraphx/instruction.hpp>
#include <migraphx/cpu/target.hpp>
#include <migraphx/verify.hpp>
8
#include "test.hpp"
Scott Thornton's avatar
Scott Thornton committed
9

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

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

Paul's avatar
Paul committed
14
TEST_CASE(slice_test)
Scott Thornton's avatar
Scott Thornton committed
15
{
Scott Thornton's avatar
Scott Thornton committed
16
    {
Paul's avatar
Paul committed
17
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
18
19
        std::vector<int> data(2 * 2 * 3);
        std::iota(data.begin(), data.end(), 0);
Paul's avatar
Paul committed
20
21
22
23
        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
24
        EXPECT(p.get_shape() == s2);
Paul's avatar
Paul committed
25
26
        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
27
28
29
30
        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
31
        EXPECT(migraphx::verify_range(results_vector, gold));
Scott Thornton's avatar
Scott Thornton committed
32
33
34
        EXPECT(result.get_shape() == sresult);
    }
    {
Paul's avatar
Paul committed
35
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
36
37
        std::vector<int> data(2 * 2 * 3);
        std::iota(data.begin(), data.end(), 0);
Paul's avatar
Paul committed
38
39
40
41
        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
42
        EXPECT(p.get_shape() == s2);
Paul's avatar
Paul committed
43
44
        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
45
46
47
48
        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
49
        EXPECT(migraphx::verify_range(results_vector, gold));
Scott Thornton's avatar
Scott Thornton committed
50
51
        EXPECT(result.get_shape() == sresult);
    }
52
53
}

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

Paul's avatar
Paul committed
104
TEST_CASE(squeeze_test)
Scott Thornton's avatar
Scott Thornton committed
105
{
106
    {
Paul's avatar
Paul committed
107
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
108
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
109
110
111
112
113
        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{});
114
        auto result = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
115
        EXPECT(result.get_shape() == s2);
116
117
    }
    {
Paul's avatar
Paul committed
118
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
119
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
120
121
122
123
124
        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{});
125
        auto result = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
126
        EXPECT(result.get_shape() == s2);
127
128
    }
    {
Paul's avatar
Paul committed
129
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
130
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
131
132
133
134
135
        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{});
136
        auto result = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
137
        EXPECT(result.get_shape() == s2);
138
139
140
    }
}

Paul's avatar
Paul committed
141
TEST_CASE(unsqueeze_test)
Scott Thornton's avatar
Scott Thornton committed
142
{
143
    {
Paul's avatar
Paul committed
144
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
145
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
146
147
148
149
150
        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{});
151
        auto result = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
152
153
        EXPECT(result.get_shape() == s2);
    }
154
    {
Paul's avatar
Paul committed
155
        migraphx::program p;
Scott Thornton's avatar
Scott Thornton committed
156
        std::vector<float> data(4 * 3 * 3);
Paul's avatar
Paul committed
157
158
159
160
161
        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{});
162
        auto result = p.eval({});
Scott Thornton's avatar
Scott Thornton committed
163
164
        EXPECT(result.get_shape() == s2);
    }
165
166
}

Paul's avatar
Paul committed
167
TEST_CASE(globalavgpool_test)
168
{
Paul's avatar
Paul committed
169
170
171
    migraphx::program p;
    auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}};
    auto op    = migraphx::op::pooling{"average"};
172
    auto lens  = s.lens();
Khalique's avatar
Khalique committed
173
    op.lengths = {lens[2], lens[3]};
174
175

    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
176
    auto l0 = p.add_literal(migraphx::literal{s, data});
177
    p.add_instruction(op, l0);
Paul's avatar
Paul committed
178
    p.compile(migraphx::cpu::target{});
179
180
181
182
183
    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
184
    EXPECT(migraphx::verify_range(results_vector, gold));
185
186
}

Paul's avatar
Paul committed
187
TEST_CASE(globalmaxpool_test)
188
{
Paul's avatar
Paul committed
189
190
191
    migraphx::program p;
    auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}};
    auto op    = migraphx::op::pooling{"max"};
192
    auto lens  = s.lens();
Khalique's avatar
Khalique committed
193
    op.lengths = {lens[2], lens[3]};
194
195

    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
196
    auto l0 = p.add_literal(migraphx::literal{s, data});
197
    p.add_instruction(op, l0);
Paul's avatar
Paul committed
198
    p.compile(migraphx::cpu::target{});
199
200
201
202
203
    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
204
    EXPECT(migraphx::verify_range(results_vector, gold));
205
206
}

Paul's avatar
Paul committed
207
TEST_CASE(im2col_3x3_no_pad_identity_test)
Scott Thornton's avatar
Scott Thornton committed
208
209
210
211
212
213
214
215
216
217
218
219
{
    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
220
221
222
223
224
225
226
    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
227
228
229
230
231
232
    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
233
    EXPECT(migraphx::verify_range(results_vector, input));
Scott Thornton's avatar
Scott Thornton committed
234
235
}

Paul's avatar
Paul committed
236
TEST_CASE(im2col_3x3_no_pad_test)
Scott Thornton's avatar
Scott Thornton committed
237
238
239
240
241
242
243
244
245
246
247
248
{
    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
249
250
251
252
253
254
255
    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
256
257
258
259
260
261
262
263
264
    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
265
    EXPECT(migraphx::verify_range(results_vector, correct));
Scott Thornton's avatar
Scott Thornton committed
266
267
}

Paul's avatar
Paul committed
268
TEST_CASE(im2col_3x3_stride_2_no_pad_test)
Scott Thornton's avatar
Scott Thornton committed
269
270
271
272
273
274
275
276
277
278
279
280
{
    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
281
282
283
284
285
286
287
    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
288
289
290
291
292
293
294
295
296
297
    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
298
    EXPECT(migraphx::verify_range(results_vector, correct));
Scott Thornton's avatar
Scott Thornton committed
299
300
}

Paul's avatar
Paul committed
301
TEST_CASE(im2col_3x3_with_padding_test)
Scott Thornton's avatar
Scott Thornton committed
302
303
304
305
306
307
308
309
310
311
312
313
{
    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
314
315
316
317
318
319
320
    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
321
322
323
324
325
326
327
328
329
    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
330
    EXPECT(migraphx::verify_range(results_vector, correct));
Scott Thornton's avatar
Scott Thornton committed
331
332
}

Paul's avatar
Paul committed
333
TEST_CASE(batch_norm_inference_test)
334
{
Paul's avatar
Paul committed
335
    migraphx::program p;
Aditya Atluri's avatar
Aditya Atluri committed
336
    const size_t width = 2, height = 2, channels = 4, batches = 2;
337
338
    const float x_val = 8.0f, mean_val = 2.0f, variance_val = 4.0f, scale_val = 2.0f,
                bias_val   = 1.0f;
Aditya Atluri's avatar
Aditya Atluri committed
339
340
    const float output_val = scale_val * (x_val - mean_val) / (std::sqrt(variance_val)) + bias_val;

Paul's avatar
Paul committed
341
342
    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
343
344
345
346
347
348
349
350
351
352
353
354
    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
355
356
357
358
359
    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
360

Paul's avatar
Paul committed
361
362
    p.add_instruction(migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
    p.compile(migraphx::cpu::target{});
363
    auto result = p.eval({});
Aditya Atluri's avatar
Aditya Atluri committed
364
365
366
367

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

Paul's avatar
Paul committed
370
    EXPECT(migraphx::verify_range(result_vector, gold));
371
372
}

Paul's avatar
Paul committed
373
TEST_CASE(im2col_3x3_with_channels_identity_test)
Scott Thornton's avatar
Scott Thornton committed
374
375
376
377
378
379
380
381
382
383
384
385
{
    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
386
387
388
389
390
391
392
    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
393
394
395
396
397
398
    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
399
    EXPECT(migraphx::verify_range(results_vector, input));
Scott Thornton's avatar
Scott Thornton committed
400
401
}

Paul's avatar
Paul committed
402
TEST_CASE(exp_test)
403
{
Paul's avatar
Paul committed
404
405
406
407
408
    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{});
409
410
    auto result = p.eval({});
    std::vector<float> results_vector(3);
411
412
    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
413
    EXPECT(migraphx::verify_range(results_vector, gold));
414
415
}

Paul's avatar
Paul committed
416
TEST_CASE(sin_test)
417
{
Paul's avatar
Paul committed
418
419
420
421
422
    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{});
423
424
    auto result = p.eval({});
    std::vector<float> results_vector(3);
425
426
    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
427
    EXPECT(migraphx::verify_range(results_vector, gold));
428
429
}

Paul's avatar
Paul committed
430
TEST_CASE(cos_test)
431
{
Paul's avatar
Paul committed
432
433
434
435
436
    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{});
437
438
    auto result = p.eval({});
    std::vector<float> results_vector(3);
439
440
    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
441
    EXPECT(migraphx::verify_range(results_vector, gold));
442
443
}

Paul's avatar
Paul committed
444
TEST_CASE(tan_test)
445
{
Paul's avatar
Paul committed
446
447
448
449
450
    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{});
451
452
    auto result = p.eval({});
    std::vector<float> results_vector(3);
453
454
    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
455
    EXPECT(migraphx::verify_range(results_vector, gold));
456
457
}

Paul's avatar
Paul committed
458
TEST_CASE(add_test)
459
{
Paul's avatar
Paul committed
460
461
462
463
464
465
    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{});
466
467
468
469
    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
470
    EXPECT(migraphx::verify_range(results_vector, gold));
471
472
}

Paul's avatar
Paul committed
473
TEST_CASE(broadcast_test)
474
{
Paul's avatar
Paul committed
475
476
    migraphx::program p;
    migraphx::shape a_shape{migraphx::shape::int32_type, {2, 2}};
477
    std::vector<int32_t> a_data{0, 0, 0, 0};
Paul's avatar
Paul committed
478
    migraphx::shape b_shape{migraphx::shape::int32_type, {2}};
479
    std::vector<int32_t> b_data{-2, -3};
480
    uint64_t axis = 0;
Paul's avatar
Paul committed
481
482
483
484
    auto l1       = p.add_literal(migraphx::literal{a_shape, a_data});
    auto l2       = p.add_literal(migraphx::literal{b_shape, b_data});
    p.add_instruction(migraphx::op::broadcast{axis, l1->get_shape()}, l2);
    p.compile(migraphx::cpu::target{});
485
    auto result = p.eval({});
Paul's avatar
Paul committed
486
    auto output = result.get<int32_t>();
Paul's avatar
Paul committed
487
488
489
490
    EXPECT(output(0, 0) == -2);
    EXPECT(output(0, 1) == -2);
    EXPECT(output(1, 0) == -3);
    EXPECT(output(1, 1) == -3);
491
}
Paul's avatar
Paul committed
492
TEST_CASE(add_broadcast_test)
493
{
494
    {
Paul's avatar
Paul committed
495
496
        migraphx::program p;
        migraphx::shape a_shape{migraphx::shape::float_type, {2, 2, 3}};
497
        std::vector<float> a_data{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
Paul's avatar
Paul committed
498
        migraphx::shape b_shape{migraphx::shape::float_type, {2, 2}};
499
500
        std::vector<float> b_data{0, -1, -2, -3};
        uint64_t axis = 0;
Paul's avatar
Paul committed
501
502
503
504
505
        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::broadcast{axis, l1->get_shape()}, l2);
        p.add_instruction(migraphx::op::add{}, l1, l3);
        p.compile(migraphx::cpu::target{});
506
507
508
509
510
        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
511
        EXPECT(migraphx::verify_range(results_vector, gold));
512
513
    }
    {
Paul's avatar
Paul committed
514
515
        migraphx::program p;
        migraphx::shape a_shape{migraphx::shape::float_type, {2, 2, 3}};
516
        std::vector<float> a_data{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
Paul's avatar
Paul committed
517
        migraphx::shape b_shape{migraphx::shape::float_type, {2, 2, 1}};
518
        std::vector<float> b_data{0, -1, -2, -3};
Paul's avatar
Paul committed
519
520
521
522
523
524
        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{});
525
526
527
528
529
        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
530
        EXPECT(migraphx::verify_range(results_vector, gold));
531
    }
532
533
}

Paul's avatar
Paul committed
534
TEST_CASE(sub_test)
535
{
Paul's avatar
Paul committed
536
537
538
539
540
541
    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{});
542
543
544
545
    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
546
    EXPECT(migraphx::verify_range(results_vector, gold));
547
548
}

Paul's avatar
Paul committed
549
TEST_CASE(mul_test)
550
{
Paul's avatar
Paul committed
551
552
553
554
555
556
    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{});
557
558
559
560
    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
561
    EXPECT(migraphx::verify_range(results_vector, gold));
562
563
}

Paul's avatar
Paul committed
564
TEST_CASE(div_test)
565
{
Paul's avatar
Paul committed
566
567
568
569
570
571
    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{});
572
573
574
575
    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
576
    EXPECT(migraphx::verify_range(results_vector, gold));
577
578
}

Paul's avatar
Paul committed
579
TEST_CASE(relu_test)
Khalique's avatar
Khalique committed
580
{
Paul's avatar
Paul committed
581
582
583
584
585
    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
586
587
588
589
    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
590
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
591
592
}

Paul's avatar
Paul committed
593
TEST_CASE(leaky_relu_test)
Khalique's avatar
Khalique committed
594
{
Paul's avatar
Paul committed
595
596
597
598
599
    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
600
601
602
603
    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
604
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
605
606
}

Paul's avatar
Paul committed
607
TEST_CASE(imagescaler_test)
Khalique's avatar
Khalique committed
608
{
Paul's avatar
Paul committed
609
610
611
    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
612
613
614
615
616
617
618
619
620
621
622
623
624
625
                                               {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
626
    auto scale_val     = p.add_literal(2.f);
Paul's avatar
Paul committed
627
628
    auto scaled_tensor = p.add_instruction(migraphx::op::scalar{s}, scale_val);
    auto img_scaled    = p.add_instruction(migraphx::op::mul{}, img, scaled_tensor);
Khalique's avatar
Khalique committed
629
    auto bias_vals     = p.add_literal(
Paul's avatar
Paul committed
630
631
632
633
        migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
    auto bias_bcast = p.add_instruction(migraphx::op::broadcast{1, s}, bias_vals);
    p.add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);
    p.compile(migraphx::cpu::target{});
Khalique's avatar
Khalique committed
634
635
636
    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
637
638
639
640
641
642
643
644
645
646
647
648
649
650
    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
651
    EXPECT(migraphx::verify_range(results_vector, gold));
Khalique's avatar
Khalique committed
652
653
}

Paul's avatar
Paul committed
654
TEST_CASE(reshape_test)
655
{
Paul's avatar
Paul committed
656
    migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
657
658
659
    std::vector<float> data(24);
    std::iota(data.begin(), data.end(), -3);
    {
Paul's avatar
Paul committed
660
661
        migraphx::program p;
        auto l                         = p.add_literal(migraphx::literal{a_shape, data});
662
        std::vector<int64_t> new_shape = {8, 3, 1, 1};
Paul's avatar
Paul committed
663
664
        p.add_instruction(migraphx::op::reshape{new_shape}, l);
        p.compile(migraphx::cpu::target{});
665
666
        auto result = p.eval({});
        std::vector<float> results_vector(3);
667
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
668
        EXPECT(migraphx::verify_range(results_vector, data));
669
670
    }
    {
Paul's avatar
Paul committed
671
672
        migraphx::program p;
        auto l                         = p.add_literal(migraphx::literal{a_shape, data});
673
        std::vector<int64_t> new_shape = {1, 3, 4, 2};
Paul's avatar
Paul committed
674
675
        p.add_instruction(migraphx::op::reshape{new_shape}, l);
        p.compile(migraphx::cpu::target{});
676
677
        auto result = p.eval({});
        std::vector<float> results_vector(3);
678
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
679
        EXPECT(migraphx::verify_range(results_vector, data));
680
681
    }
    {
Paul's avatar
Paul committed
682
683
        migraphx::program p;
        auto l                         = p.add_literal(migraphx::literal{a_shape, data});
684
        std::vector<int64_t> new_shape = {1, 3, 4, 2};
Paul's avatar
Paul committed
685
686
        p.add_instruction(migraphx::op::reshape{new_shape}, l);
        p.compile(migraphx::cpu::target{});
687
688
        auto result = p.eval({});
        std::vector<float> results_vector(3);
689
        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
690
        EXPECT(migraphx::verify_range(results_vector, data));
691
692
693
    }
}

Paul's avatar
Paul committed
694
template <class T>
695
696
void gemm_test()
{
Paul's avatar
Paul committed
697
    migraphx::program p;
Paul's avatar
Paul committed
698
    std::vector<T> a = {-0.00925222, 0.56250403, 0.70107397,  0.75402161,  -0.505885,
Paul's avatar
Paul committed
699
700
701
                        1.33628943,  -0.11413,   -0.31270559, 1.59336732,  -0.19361027,
                        -0.91620867, 0.40108416, -0.06969921, 0.68483471,  -0.39906632,
                        -1.66423624, 0.69040076, -1.31490171, -0.11282616, -0.79391814};
Paul's avatar
Paul committed
702
    std::vector<T> b = {6.09568541e-01,
Paul's avatar
Paul committed
703
704
705
706
707
708
709
710
711
712
713
714
715
716
                        -6.10527007e-01,
                        3.66646462e-01,
                        1.18951101e-01,
                        5.58777432e-01,
                        -3.21296298e-01,
                        -5.95997198e-01,
                        -5.01425721e-01,
                        -2.84606807e-01,
                        -5.73673557e-01,
                        -8.99430260e-01,
                        -4.25103093e-01,
                        1.53027987e+00,
                        -3.81407415e-04,
                        -3.29650255e-01};
Paul's avatar
Paul committed
717
    std::vector<T> c = {-1.56327541e+00,
Paul's avatar
Paul committed
718
719
720
721
722
723
724
725
726
727
728
                        -7.09570140e-01,
                        -5.37424982e-01,
                        -2.22994831e-01,
                        -2.15586437e+00,
                        2.09177941e-03,
                        -1.47279677e+00,
                        2.02627040e-01,
                        -6.04527691e-01,
                        -1.29885596e+00,
                        2.16294914e+00,
                        -1.48101497e-01};
Paul's avatar
Paul committed
729
730
731
732
733
734
    migraphx::shape a_shape{migraphx::shape::get_type<T>{}, {4, 5}};
    auto al = p.add_literal(migraphx::literal{a_shape, a});
    migraphx::shape b_shape{migraphx::shape::get_type<T>{}, {5, 3}};
    auto bl = p.add_literal(migraphx::literal{b_shape, b});
    p.add_instruction(migraphx::op::dot{}, al, bl);
    p.compile(migraphx::cpu::target{});
735
    auto result = p.eval({});
Paul's avatar
Paul committed
736
    std::vector<T> results_vector(12);
737
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
738
    float tol = 1e-6;
739
740
741
    for(int i = 0; i < results_vector.size(); i++)
    {
        EXPECT(std::abs(results_vector[i] - c[i]) < tol);
742
743
    }
}
Paul's avatar
Paul committed
744
745
TEST_CASE_REGISTER(gemm_test<float>)
TEST_CASE_REGISTER(gemm_test<double>)
746

Paul's avatar
Paul committed
747
TEST_CASE(maxpool_test)
748
{
Paul's avatar
Paul committed
749
    migraphx::program p;
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
    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
788
789
790
791
    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{});
792
    auto result = p.eval({});
Paul's avatar
Paul committed
793
    // std::cout << result.get_shape() << std::endl;
794
795
796
797
798
799
800
801
802
803
    std::vector<float> results_vector(36);
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
    float tol = 1e-6;
    for(int i = 0; i < results_vector.size(); i++)
    {
        // std::cout << results_vector[i] << "          " << c[i] << std::endl;
        EXPECT(std::abs(results_vector[i] - c[i]) < tol);
    }
}

Paul's avatar
Paul committed
804
TEST_CASE(softmax_test)
805
{
Paul's avatar
Paul committed
806
    migraphx::program p;
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
    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
853
854
855
856
    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{});
857
858
    auto result = p.eval({});
    std::vector<float> results_vector(120);
859
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
860
    EXPECT(migraphx::verify_range(results_vector, s));
Scott Thornton's avatar
Scott Thornton committed
861
862
}

Paul's avatar
Paul committed
863
TEST_CASE(conv2d_test)
864
{
Paul's avatar
Paul committed
865
    migraphx::program p;
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
    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
910
                            -0.46427044};
Paul's avatar
Paul committed
911
912
    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
913

Paul's avatar
Paul committed
914
915
    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
916

Paul's avatar
Paul committed
917
918
    p.add_instruction(migraphx::op::convolution{}, al, cl);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
919
920
921
    auto result = p.eval({});

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

Paul's avatar
Paul committed
926
TEST_CASE(conv2d_padding_test)
927
{
Paul's avatar
Paul committed
928
    migraphx::program p;
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
    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
967
968
    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
969

Paul's avatar
Paul committed
970
971
    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
972

Paul's avatar
Paul committed
973
974
    p.add_instruction(migraphx::op::convolution{{{1, 1}}, {{1, 1}}}, al, cl);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
975
976
977
    auto result = p.eval({});

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

Paul's avatar
Paul committed
982
TEST_CASE(conv2d_padding_stride_test)
983
{
Paul's avatar
Paul committed
984
    migraphx::program p;
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
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
    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
1028
1029
    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
1030

Paul's avatar
Paul committed
1031
1032
    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
1033

Paul's avatar
Paul committed
1034
1035
    p.add_instruction(migraphx::op::convolution{{{1, 1}}, {{2, 2}}}, al, cl);
    p.compile(migraphx::cpu::target{});
Scott Thornton's avatar
Scott Thornton committed
1036
1037
1038
    auto result = p.eval({});

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

Paul's avatar
Paul committed
1043
TEST_CASE(transpose_test)
1044
{
Paul's avatar
Paul committed
1045
    migraphx::shape a_shape{migraphx::shape::float_type, {1, 2, 2, 3}};
1046
1047
1048
    std::vector<float> data(12);
    std::iota(data.begin(), data.end(), 0);

1049
    {
Paul's avatar
Paul committed
1050
1051
        migraphx::program p;
        auto l                    = p.add_literal(migraphx::literal{a_shape, data});
Paul's avatar
Paul committed
1052
        std::vector<int64_t> perm = {0, 3, 1, 2};
Paul's avatar
Paul committed
1053
1054
        p.add_instruction(migraphx::op::transpose{perm}, l);
        p.compile(migraphx::cpu::target{});
1055
        auto result = p.eval({});
1056

Paul's avatar
Paul committed
1057
        result.visit([&](auto output) {
Paul's avatar
Paul committed
1058
            std::vector<size_t> new_lens = {1, 3, 2, 2};
Paul's avatar
Paul committed
1059
1060
            EXPECT(bool{output.get_shape().lens() == new_lens});
        });
1061
1062
    }
    {
Paul's avatar
Paul committed
1063
1064
        migraphx::program p;
        auto l                    = p.add_literal(migraphx::literal{a_shape, data});
Paul's avatar
Paul committed
1065
        std::vector<int64_t> perm = {0, 3, 1, 2};
Paul's avatar
Paul committed
1066
1067
1068
        auto result               = p.add_instruction(migraphx::op::transpose{perm}, l);
        p.add_instruction(migraphx::op::contiguous{}, result);
        p.compile(migraphx::cpu::target{});
1069
1070
1071
1072
1073
        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
1074
        EXPECT(migraphx::verify_range(results_vector, gold));
1075
    }
1076
1077
}

Paul's avatar
Paul committed
1078
TEST_CASE(contiguous_test)
Paul's avatar
Paul committed
1079
{
Paul's avatar
Paul committed
1080
    migraphx::shape a_shape{migraphx::shape::float_type, {1, 3, 2, 2}, {12, 1, 6, 3}};
1081
1082
1083
    std::vector<float> data(12);
    std::iota(data.begin(), data.end(), 0);

Paul's avatar
Paul committed
1084
1085
1086
1087
    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{});
1088
1089
1090
    auto result = p.eval({});

    std::vector<float> results_vector(12);
1091
    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
Paul's avatar
Paul committed
1092
1093
    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
1094
    std::vector<float> gold         = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
Paul's avatar
Paul committed
1095
    EXPECT(migraphx::verify_range(results_vector, gold));
1096
1097
}

Khalique's avatar
Khalique committed
1098
1099
TEST_CASE(identity_test)
{
Khalique's avatar
Khalique committed
1100
1101
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
Khalique's avatar
Khalique committed
1102
    std::vector<int> data{1, 2, 3, 4};
Khalique's avatar
Khalique committed
1103
1104
1105
    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
1106
1107
1108
1109
1110
1111
    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
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
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));
}

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
1158
    auto l      = p.add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
Khalique's avatar
Khalique committed
1159
1160
1161
1162
1163
1164
    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
1165
    std::vector<float> gold{elu(alpha, -1), elu(alpha, 2), elu(alpha, -3), elu(alpha, 4)};
Khalique's avatar
Khalique committed
1166
1167
1168
    EXPECT(migraphx::verify_range(results_vector, gold));
}

Khalique's avatar
Khalique committed
1169
1170
1171
1172
TEST_CASE(max_test)
{
    migraphx::program p;
    migraphx::shape s{migraphx::shape::float_type, {3}};
Khalique's avatar
Khalique committed
1173
1174
1175
    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
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
    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
1190
1191
1192
    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
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
    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));
}

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