tf_test.cpp 12.7 KB
Newer Older
1
2
3
#include <iostream>
#include <vector>
#include <migraphx/literal.hpp>
Paul's avatar
Paul committed
4
5
6
7
#include <migraphx/pass_manager.hpp>
#include <migraphx/simplify_reshapes.hpp>
#include <migraphx/dead_code_elimination.hpp>
#include <migraphx/eliminate_identity.hpp>
8
9
10
11
12
13
#include <migraphx/operators.hpp>
#include <migraphx/program.hpp>
#include <migraphx/instruction.hpp>
#include <migraphx/tf.hpp>
#include "test.hpp"

Paul's avatar
Paul committed
14
15
16
migraphx::program optimize_tf(const std::string& name, bool is_nhwc)
{
    auto prog = migraphx::parse_tf(name, is_nhwc);
Paul's avatar
Paul committed
17
18
19
20
21
    if(is_nhwc)
        migraphx::run_passes(prog,
                             {migraphx::simplify_reshapes{},
                              migraphx::dead_code_elimination{},
                              migraphx::eliminate_identity{}});
Paul's avatar
Paul committed
22
23
24
    return prog;
}

25
26
27
28
29
30
TEST_CASE(add_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
    p.add_instruction(migraphx::op::add{}, l0, l1);
Paul's avatar
Paul committed
31
    auto prog = optimize_tf("add_test.pb", false);
32
33
34
35
36
37

    EXPECT(p == prog);
}

TEST_CASE(add_bcast_test)
{
Khalique's avatar
Khalique committed
38

39
40
41
42
43
44
45
    migraphx::program p;
    migraphx::shape s0{migraphx::shape::float_type, {2, 3}};
    auto l0 = p.add_parameter("0", s0);
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2, 1}});
    auto l2 = p.add_instruction(migraphx::op::multibroadcast{s0.lens()}, l0);
    auto l3 = p.add_instruction(migraphx::op::multibroadcast{s0.lens()}, l1);
    p.add_instruction(migraphx::op::add{}, l2, l3);
Paul's avatar
Paul committed
46
    auto prog = optimize_tf("add_bcast_test.pb", false);
47
48
49
50

    EXPECT(p == prog);
}

51
52
TEST_CASE(batchnorm_test)
{
Khalique's avatar
Khalique committed
53
54
    float epsilon  = 1.001e-5f;
    float momentum = 0.9f;
55
56

    migraphx::program p;
Khalique's avatar
Khalique committed
57
58
    migraphx::op::batch_norm_inference op{
        epsilon, momentum, migraphx::op::batch_norm_inference::spatial};
59
    migraphx::shape s0{migraphx::shape::float_type, {32}};
60
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 32, 16, 16}});
61
62
    std::vector<float> const_vals(32);
    std::fill(const_vals.begin(), const_vals.end(), 1.0f);
Khalique's avatar
Khalique committed
63

64
65
66
67
68
    auto l2 = p.add_parameter("2", s0);
    auto l3 = p.add_parameter("3", s0);
    auto l4 = p.add_parameter("4", s0);
    auto l1 = p.add_literal(migraphx::literal{s0, const_vals});
    p.add_instruction(op, l0, l1, l2, l3, l4);
Paul's avatar
Paul committed
69
    auto prog = optimize_tf("batchnorm_test.pb", true);
70
71
72
73

    EXPECT(p == prog);
}

74
75
76
TEST_CASE(biasadd_test)
{
    migraphx::program p;
77
    migraphx::shape s0{migraphx::shape::float_type, {1, 500, 1, 1}};
78
    uint64_t axis = 1;
Khalique's avatar
Khalique committed
79
    auto l0       = p.add_parameter("0", s0);
80
    auto l1       = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {500}});
81
    auto l2       = p.add_instruction(migraphx::op::broadcast{axis, l0->get_shape().lens()}, l1);
82
    p.add_instruction(migraphx::op::add{}, l0, l2);
Paul's avatar
Paul committed
83
    auto prog = optimize_tf("biasadd_test.pb", true);
84
85
86
87

    EXPECT(p == prog);
}

88
89
90
TEST_CASE(concat_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
91

92
93
94
95
96
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {4, 7, 3}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 2, 3}});

    int axis = 1;
    // tf uses axis as the third input, and it is in int32 format
Khalique's avatar
Khalique committed
97
    // add the literal using a vector in order to set stride to 1 (like in tf parser)
98
    p.add_literal(migraphx::shape{migraphx::shape::int32_type}, std::vector<int>{axis});
99
100

    p.add_instruction(migraphx::op::concat{static_cast<std::size_t>(axis)}, l0, l1);
Paul's avatar
Paul committed
101
    auto prog = optimize_tf("concat_test.pb", false);
102
103
104
105
106
107
108

    EXPECT(p == prog);
}

TEST_CASE(const_test)
{
    migraphx::program p;
109
    p.add_literal(migraphx::shape{migraphx::shape::float_type}, std::vector<float>{1.0f});
Paul's avatar
Paul committed
110
    auto prog = optimize_tf("constant_test.pb", false);
111
112
113
114
115
116
117

    EXPECT(p == prog);
}

TEST_CASE(conv_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
118

119
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
Khalique's avatar
Khalique committed
120
    std::vector<float> weight_data(3 * 3 * 3 * 32);
121
    std::fill(weight_data.begin(), weight_data.end(), 1.0f);
Khalique's avatar
Khalique committed
122
123
    auto l1 =
        p.add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 32}}, weight_data);
124
125
126

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
Khalique's avatar
Khalique committed
127
128
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
Paul's avatar
Paul committed
129
130
131
    auto l2         = p.add_instruction(migraphx::op::transpose{{3, 2, 0, 1}}, l1);
    p.add_instruction(op, l0, l2);
    auto prog = optimize_tf("conv_test.pb", true);
132
133
134
135

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
TEST_CASE(depthwiseconv_test)
{
    migraphx::program p;

    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    std::vector<float> weight_data(3 * 3 * 3 * 1);
    std::fill(weight_data.begin(), weight_data.end(), 1.0f);
    auto l1 =
        p.add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 1}}, weight_data);

    migraphx::op::convolution op;
    op.padding_mode = migraphx::op::padding_mode_t::same;
    op.stride       = {1, 1};
    op.dilation     = {1, 1};
    op.group        = 3;
Paul's avatar
Paul committed
151
    auto l3         = p.add_instruction(migraphx::op::transpose{{3, 2, 0, 1}}, l1);
Paul's avatar
Paul committed
152
153
154
    auto l4         = p.add_instruction(migraphx::op::contiguous{}, l3);
    auto l5         = p.add_instruction(migraphx::op::reshape{{3, 1, 3, 3}}, l4);
    p.add_instruction(op, l0, l5);
Paul's avatar
Paul committed
155
    auto prog = optimize_tf("depthwise_conv_test.pb", true);
Khalique's avatar
Khalique committed
156
157
158
159

    EXPECT(p == prog);
}

160
161
162
163
164
TEST_CASE(identity_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    p.add_instruction(migraphx::op::identity{}, l0);
Paul's avatar
Paul committed
165
    auto prog = optimize_tf("identity_test.pb", false);
166
167
168
169

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
170
171
172
173
174
TEST_CASE(matmul_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {8, 4}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 8}});
Khalique's avatar
Khalique committed
175
176
177

    auto trans_l0 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l0);
    auto trans_l1 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l1);
Khalique's avatar
Khalique committed
178
179

    p.add_instruction(migraphx::op::dot{}, trans_l0, trans_l1);
Paul's avatar
Paul committed
180
    auto prog = optimize_tf("matmul_test.pb", false);
Khalique's avatar
Khalique committed
181
182
183
184

    EXPECT(p == prog);
}

185
186
187
TEST_CASE(mean_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
188
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {2, 3}};
189
190
191
192
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    p.add_literal(l);
    p.add_literal(l);
    migraphx::op::pooling op;
Khalique's avatar
Khalique committed
193
    op.lengths = {16, 16};
Paul's avatar
Paul committed
194
    p.add_instruction(op, l0);
Paul's avatar
Paul committed
195
    auto l3 = p.add_instruction(op, l0);
Khalique's avatar
Khalique committed
196
    p.add_instruction(migraphx::op::squeeze{{2, 3}}, l3);
Paul's avatar
Paul committed
197
    auto prog = optimize_tf("mean_test.pb", false);
198
199
200
201
202
203
204

    EXPECT(p == prog);
}

TEST_CASE(mean_test_nhwc)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
205
    migraphx::literal l{migraphx::shape{migraphx::shape::int32_type, {2}}, {1, 2}};
206
207
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    migraphx::op::pooling op;
Khalique's avatar
Khalique committed
208
209
210
    op.lengths = {16, 16};
    auto l3    = p.add_instruction(op, l0);
    p.add_instruction(migraphx::op::squeeze{{2, 3}}, l3);
Paul's avatar
Paul committed
211
    auto prog = optimize_tf("mean_test_nhwc.pb", true);
212
213
214
215

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
216
217
218
TEST_CASE(mul_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
219
220
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 1, 1, 16}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 1, 16}});
Khalique's avatar
Khalique committed
221
222

    p.add_instruction(migraphx::op::mul{}, l0, l1);
Paul's avatar
Paul committed
223
    auto prog = optimize_tf("mul_test.pb", false);
Khalique's avatar
Khalique committed
224
225
226
227

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
228
229
230
231
232
233
234
235
236
237
TEST_CASE(pack_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2}});
    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2}});
    auto l2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {2}});
    std::vector<migraphx::instruction_ref> args{l0, l1, l2};
    std::vector<migraphx::instruction_ref> unsqueezed_args;
    int64_t axis = 1;

Khalique's avatar
Khalique committed
238
239
240
241
242
243
    std::transform(args.begin(),
                   args.end(),
                   std::back_inserter(unsqueezed_args),
                   [&](migraphx::instruction_ref arg) {
                       return p.add_instruction(migraphx::op::unsqueeze{{axis}}, arg);
                   });
Khalique's avatar
Khalique committed
244
    p.add_instruction(migraphx::op::concat{static_cast<size_t>(axis)}, unsqueezed_args);
Paul's avatar
Paul committed
245
    auto prog = optimize_tf("pack_test.pb", false);
Khalique's avatar
Khalique committed
246
247
248
249

    EXPECT(p == prog);
}

250
251
252
TEST_CASE(pack_test_nhwc)
{
    migraphx::program p;
Paul's avatar
Paul committed
253
    auto l0  = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
Paul's avatar
Paul committed
254
    auto lt0 = p.add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l0);
Paul's avatar
Paul committed
255
    auto l1  = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
Paul's avatar
Paul committed
256
    auto lt1 = p.add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l1);
Paul's avatar
Paul committed
257
    auto l2  = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
Paul's avatar
Paul committed
258
259
    auto lt2 = p.add_instruction(migraphx::op::transpose{{0, 2, 3, 1}}, l2);
    std::vector<migraphx::instruction_ref> args{lt0, lt1, lt2};
260
    std::vector<migraphx::instruction_ref> unsqueezed_args;
Paul's avatar
Paul committed
261
    int64_t nchw_axis = 3;
262
263
264
265
266
267
268
269

    std::transform(args.begin(),
                   args.end(),
                   std::back_inserter(unsqueezed_args),
                   [&](migraphx::instruction_ref arg) {
                       return p.add_instruction(migraphx::op::unsqueeze{{nchw_axis}}, arg);
                   });
    p.add_instruction(migraphx::op::concat{static_cast<size_t>(nchw_axis)}, unsqueezed_args);
Paul's avatar
Paul committed
270
    auto prog = optimize_tf("pack_test_nhwc.pb", true);
271
272
273
274

    EXPECT(p == prog);
}

275
276
277
TEST_CASE(pooling_test)
{
    migraphx::program p;
278
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
279
280
281
282
    migraphx::op::pooling avg_pool_op{"average"};
    migraphx::op::pooling max_pool_op{"max"};
    avg_pool_op.padding_mode = migraphx::op::padding_mode_t::valid;
    max_pool_op.padding_mode = migraphx::op::padding_mode_t::valid;
Khalique's avatar
Khalique committed
283
284
285
286
    avg_pool_op.stride       = {2, 2};
    max_pool_op.stride       = {2, 2};
    avg_pool_op.lengths      = {2, 2};
    max_pool_op.lengths      = {2, 2};
287
    p.add_instruction(max_pool_op, l0);
Paul's avatar
Paul committed
288
289
    // p.add_instruction(avg_pool_op, l0);
    auto prog = optimize_tf("pooling_test.pb", true);
290
291
292
293

    EXPECT(p == prog);
}

294
295
296
297
298
TEST_CASE(relu_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    p.add_instruction(migraphx::op::relu{}, l0);
Paul's avatar
Paul committed
299
    auto prog = optimize_tf("relu_test.pb", false);
300
301
302
303

    EXPECT(p == prog);
}

Khalique's avatar
Khalique committed
304
305
306
307
308
TEST_CASE(relu6_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
    p.add_instruction(migraphx::op::clip{6.0, 0.0}, l0);
Paul's avatar
Paul committed
309
    auto prog = optimize_tf("relu6_test.pb", false);
Khalique's avatar
Khalique committed
310
311
312
313

    EXPECT(p == prog);
}

314
315
316
317
318
319
TEST_CASE(reshape_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {16}});
    migraphx::shape s0{migraphx::shape::int32_type, {4}};
    // in tf, the second arg is a literal that contains new dimensions
Khalique's avatar
Khalique committed
320
321
    p.add_literal(migraphx::literal{s0, {1, 1, 1, 16}});
    p.add_instruction(migraphx::op::reshape{{1, 1, 1, 16}}, l0);
Paul's avatar
Paul committed
322
    auto prog = optimize_tf("reshape_test.pb", false);
323
324
325
326
327
328
329

    EXPECT(p == prog);
}

TEST_CASE(softmax_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
330
    auto l0   = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
331
    auto dims = l0->get_shape().lens();
Khalique's avatar
Khalique committed
332
333
    auto r    = p.add_instruction(migraphx::op::reshape{{long(dims[0]), long(dims[1]), 1, 1}}, l0);
    auto s    = p.add_instruction(migraphx::op::softmax{}, r);
334
    p.add_instruction(migraphx::op::reshape{{long(dims[0]), long(dims[1])}}, s);
Paul's avatar
Paul committed
335
    auto prog = optimize_tf("softmax_test.pb", false);
336
337
338
339
340
341
342

    EXPECT(p == prog);
}

TEST_CASE(squeeze_test)
{
    migraphx::program p;
Khalique's avatar
Khalique committed
343
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 3, 1}});
344
    p.add_instruction(migraphx::op::squeeze{{0, 3}}, l0);
Paul's avatar
Paul committed
345
    auto prog = optimize_tf("squeeze_test.pb", false);
346
347
348

    EXPECT(p == prog);
}
Khalique's avatar
Khalique committed
349
350
351
352
353
354
355

TEST_CASE(stridedslice_test)
{
    migraphx::program p;
    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 10, 1, 1}});
    std::size_t num_axes = 4;
    migraphx::op::slice op;
Khalique's avatar
Khalique committed
356
    op.starts = {0, 0, 0, 0};
Paul's avatar
Paul committed
357
    op.ends   = {1, 1, 1, 5};
Khalique's avatar
Khalique committed
358
359
    op.axes   = std::vector<int64_t>(num_axes);
    std::iota(op.axes.begin(), op.axes.end(), 0);
Khalique's avatar
Khalique committed
360
    auto l1          = p.add_instruction(op, l0);
Paul's avatar
Paul committed
361
    auto shrink_axis = 1;
Khalique's avatar
Khalique committed
362
    p.add_instruction(migraphx::op::squeeze{{shrink_axis}}, l1);
Paul's avatar
Paul committed
363
    auto prog = optimize_tf("stridedslice_test.pb", true);
Khalique's avatar
Khalique committed
364
365
366
367

    EXPECT(p == prog);
}

368
int main(int argc, const char* argv[]) { test::run(argc, argv); }