verify_onnx.cpp 8.91 KB
Newer Older
kahmed10's avatar
kahmed10 committed
1
2
3
4
5
#include <iostream>
#include <vector>
#include <migraphx/literal.hpp>
#include <migraphx/operators.hpp>
#include <migraphx/program.hpp>
6
#include <migraphx/ref/target.hpp>
kahmed10's avatar
kahmed10 committed
7
8
9
10
11
#include <migraphx/pass_manager.hpp>
#include <migraphx/verify.hpp>
#include <migraphx/onnx.hpp>
#include "test.hpp"

Shucai Xiao's avatar
Shucai Xiao committed
12
13
14
TEST_CASE(averagepool_notset_test)
{
    auto p = migraphx::parse_onnx("averagepool_notset_test.onnx");
15
    p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
16
17
18
    std::vector<float> data_x = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
                                 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
    migraphx::shape s_x{migraphx::shape::float_type, {1, 1, 5, 5}};
19
    migraphx::parameter_map pp;
Shucai Xiao's avatar
Shucai Xiao committed
20
21
22
23
24
25
26
27
28
29
30
31
32
    pp["x"] = migraphx::argument(s_x, data_x.data());

    auto result = p.eval(pp).back();
    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

    std::vector<float> gold = {12};
    EXPECT(migraphx::verify_range(result_vector, gold));
}

TEST_CASE(averagepool_nt_cip_test)
{
    auto p = migraphx::parse_onnx("averagepool_nt_cip_test.onnx");
33
    p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
34
35
36
    std::vector<float> data_x = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
                                 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
    migraphx::shape s_x{migraphx::shape::float_type, {1, 1, 5, 5}};
37
    migraphx::parameter_map pp;
Shucai Xiao's avatar
Shucai Xiao committed
38
39
40
41
42
43
44
45
46
47
48
49
50
    pp["x"] = migraphx::argument(s_x, data_x.data());

    auto result = p.eval(pp).back();
    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

    std::vector<float> gold = {8.33333};
    EXPECT(migraphx::verify_range(result_vector, gold));
}

TEST_CASE(gather_elements)
{
    migraphx::program p = migraphx::parse_onnx("gather_elements_axis0_test.onnx");
51
    p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
52
53
54
55
56
57
58
    migraphx::shape s_data{migraphx::shape::float_type, {3, 4}};
    std::vector<float> data = {
        0.25, 0.75, 0.9375, 0.4375, 0.6875, 0.5625, -0.875, 0.1875, -0.125, 0.5, -0.9375, -0.0625};

    migraphx::shape s_ind{migraphx::shape::int32_type, {2, 3}};
    std::vector<int> ind = {2, 1, 2, 0, 1, 0};

59
    migraphx::parameter_map pp;
Shucai Xiao's avatar
Shucai Xiao committed
60
61
62
63
64
65
66
67
68
69
70
    pp["data"]    = migraphx::argument(s_data, data.data());
    pp["indices"] = migraphx::argument(s_ind, ind.data());

    auto result = p.eval(pp).back();
    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

    std::vector<float> gold = {-0.125, 0.5625, -0.9375, 0.25, 0.5625, 0.9375};
    EXPECT(migraphx::verify_range(result_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
TEST_CASE(if_else_test)
{
    migraphx::program p = migraphx::parse_onnx("if_else_test.onnx");
    p.compile(migraphx::ref::target{});
    migraphx::shape s_data{migraphx::shape::float_type, {2, 3}};
    std::vector<float> data = {0.0625, 0.75, -0.0625, 0.125, -0.125, -0.5625};

    migraphx::parameter_map pp;
    pp["y"] = migraphx::argument(s_data, data.data());

    auto result = p.eval(pp).back();
    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

    std::vector<float> gold = {
        -0.0364609435, 0.475317657, -0.00417715637, -0.0599277429, 0.0755792186, -0.0218581557};
    EXPECT(migraphx::verify_range(result_vector, gold));
}

kahmed10's avatar
kahmed10 committed
90
91
92
93
TEST_CASE(instance_norm_test)
{
    migraphx::program p = migraphx::parse_onnx("instance_norm_val_test.onnx");

94
    p.compile(migraphx::ref::target{});
95
    auto result = p.eval({}).back();
kahmed10's avatar
kahmed10 committed
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
    std::vector<float> result_vector(9);
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

    std::vector<float> gold = {-1.54919,
                               -1.16189,
                               -0.774596,
                               -0.387298,
                               0,
                               0.387298,
                               0.774596,
                               1.16189,
                               1.54919,
                               -2.09838,
                               -1.32379,
                               -0.549192,
                               0.225404,
                               1,
                               1.7746,
                               2.54919,
                               3.32379,
                               4.09838};
    EXPECT(migraphx::verify_range(result_vector, gold));
118
119
}

kahmed10's avatar
kahmed10 committed
120
121
122
123
TEST_CASE(instance_norm_3d_test)
{
    migraphx::program p = migraphx::parse_onnx("instance_norm_val_3d_test.onnx");

124
    p.compile(migraphx::ref::target{});
kahmed10's avatar
kahmed10 committed
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
    auto result = p.eval({}).back();
    std::vector<float> result_vector(16);
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

    std::vector<float> gold = {-1.52752,
                               -1.09109,
                               -0.654653,
                               -0.218218,
                               0.218218,
                               0.654653,
                               1.09109,
                               1.52752,
                               -2.05505,
                               -1.18218,
                               -0.309306,
                               0.563565,
                               1.43644,
                               2.30931,
                               3.18218,
                               4.05505};

    EXPECT(migraphx::verify_range(result_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
149
TEST_CASE(resize_test)
150
{
Shucai Xiao's avatar
Shucai Xiao committed
151
    migraphx::program p = migraphx::parse_onnx("resize_upsample_pf_test.onnx");
152
    p.compile(migraphx::ref::target{});
153

Shucai Xiao's avatar
Shucai Xiao committed
154
155
    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
    std::vector<float> dx = {1.0f, 2.0f, 3.0f, 4.0f};
156

157
    migraphx::parameter_map pp;
Shucai Xiao's avatar
Shucai Xiao committed
158
    pp["X"] = migraphx::argument(sx, dx.data());
159
160
161
162
163

    auto result = p.eval(pp).back();
    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

Shucai Xiao's avatar
Shucai Xiao committed
164
165
166
    std::vector<float> gold = {1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2,
                               3, 3, 3, 4, 4, 4, 3, 3, 3, 4, 4, 4};

167
    EXPECT(migraphx::verify_range(result_vector, gold));
kahmed10's avatar
kahmed10 committed
168
169
}

Shucai Xiao's avatar
Shucai Xiao committed
170
TEST_CASE(selu_test)
Shucai Xiao's avatar
Shucai Xiao committed
171
{
Shucai Xiao's avatar
Shucai Xiao committed
172
    migraphx::program p = migraphx::parse_onnx("selu_test.onnx");
173
    p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
174

Shucai Xiao's avatar
Shucai Xiao committed
175
176
    migraphx::shape xs{migraphx::shape::double_type, {2, 3}};
    std::vector<double> x_data = {1.1, 2.1, 0.0, -1.3, -5.3, 12.0};
Shucai Xiao's avatar
Shucai Xiao committed
177

178
    migraphx::parameter_map pp;
Shucai Xiao's avatar
Shucai Xiao committed
179
    pp["x"] = migraphx::argument(xs, x_data.data());
Shucai Xiao's avatar
Shucai Xiao committed
180
181
182
183
184

    auto result = p.eval(pp).back();
    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

Shucai Xiao's avatar
Shucai Xiao committed
185
186
    std::vector<float> gold = {0.55, 1.05, 0, -0.10912, -0.149251, 6};

Shucai Xiao's avatar
Shucai Xiao committed
187
188
189
    EXPECT(migraphx::verify_range(result_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
190
191
192
193
194
195
196
TEST_CASE(upsample_test)
{
    migraphx::program p = migraphx::parse_onnx("upsample_test.onnx");

    std::vector<float> x_data = {1, 2, 3, 4};
    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};

197
    migraphx::parameter_map pp;
Shucai Xiao's avatar
Shucai Xiao committed
198
199
200
201
202
203
204
205
206
207
208
    pp["X"] = migraphx::argument(sx, x_data.data());

    auto result = p.eval(pp).back();
    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

    std::vector<float> gold = {1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2,
                               3, 3, 3, 4, 4, 4, 3, 3, 3, 4, 4, 4};
    EXPECT(migraphx::verify_range(result_vector, gold));
}

Shucai Xiao's avatar
Shucai Xiao committed
209
210
211
TEST_CASE(where_test)
{
    migraphx::program p = migraphx::parse_onnx("where_test.onnx");
212
    p.compile(migraphx::ref::target{});
Shucai Xiao's avatar
Shucai Xiao committed
213
214
215
216
217
218
219
220
221
222

    migraphx::shape c_shape{migraphx::shape::bool_type, {2}};
    std::vector<int8_t> c_data = {1, 0};

    migraphx::shape x_shape{migraphx::shape::float_type, {2, 2, 2}};
    std::vector<float> x_data(8, 1.0f);

    migraphx::shape y_shape{migraphx::shape::float_type, {2, 1, 2, 2}};
    std::vector<float> y_data(8, 2.0f);

223
    migraphx::parameter_map pp;
Shucai Xiao's avatar
Shucai Xiao committed
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
    pp["c"] = migraphx::argument(c_shape, c_data.data());
    pp["x"] = migraphx::argument(x_shape, x_data.data());
    pp["y"] = migraphx::argument(y_shape, y_data.data());

    auto result = p.eval(pp).back();
    std::vector<float> result_vector;
    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });

    std::vector<float> gold = {1.0f,
                               2.0f,
                               1.0f,
                               2.0f,
                               1.0f,
                               2.0f,
                               1.0f,
                               2.0f,
                               1.0f,
                               2.0f,
                               1.0f,
                               2.0f,
                               1.0f,
                               2.0f,
                               1.0f,
                               2.0f};
    EXPECT(migraphx::verify_range(result_vector, gold));
}

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