onnx.cpp 64.8 KB
Newer Older
Paul's avatar
Paul committed
1
2
3
4
5
6
7
8
#include <google/protobuf/text_format.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <onnx.pb.h>
#include <iostream>
#include <fstream>
#include <unordered_map>
#include <functional>
#include <array>
Paul's avatar
Paul committed
9
#include <utility>
10
#include <vector>
Paul's avatar
Paul committed
11

Paul's avatar
Paul committed
12
13
14
15
16
17
#include <migraphx/fallthrough.hpp>
#include <migraphx/program.hpp>
#include <migraphx/operators.hpp>
#include <migraphx/ranges.hpp>
#include <migraphx/instruction.hpp>
#include <migraphx/config.hpp>
18
#include <migraphx/onnx.hpp>
Paul's avatar
Paul committed
19
20

namespace migraphx {
Paul's avatar
Paul committed
21
inline namespace MIGRAPHX_INLINE_NS {
Paul's avatar
Paul committed
22
23
24
25
26

struct onnx_parser
{
    using attribute_map = std::unordered_map<std::string, onnx::AttributeProto>;
    using node_map      = std::unordered_map<std::string, onnx::NodeProto>;
Paul's avatar
Paul committed
27
28
    using op_func =
        std::function<std::vector<instruction_ref>(attribute_map, std::vector<instruction_ref>)>;
Paul's avatar
Paul committed
29
30
    node_map nodes;
    std::unordered_map<std::string, instruction_ref> instructions;
Scott Thornton's avatar
Scott Thornton committed
31
    program prog    = program();
32
    bool is_pytorch = false;
Paul's avatar
Paul committed
33
34

    std::unordered_map<std::string, op_func> ops;
35
    std::unordered_map<std::string, operation> map_actv_funcs;
Paul's avatar
Paul committed
36
37
38

    onnx_parser()
    {
Khalique's avatar
Khalique committed
39
        add_generic_op("Relu", op::relu{});
Khalique's avatar
Khalique committed
40
41
        add_generic_op("Sigmoid", op::sigmoid{});
        add_generic_op("Abs", op::abs{});
Shucai Xiao's avatar
Shucai Xiao committed
42
        add_generic_op("Exp", op::exp{});
Shucai Xiao's avatar
Shucai Xiao committed
43
        add_generic_op("Erf", op::erf{});
Shucai Xiao's avatar
Shucai Xiao committed
44
        add_generic_op("Log", op::log{});
Khalique's avatar
Khalique committed
45
46
        // disable dropout for inference
        add_generic_op("Dropout", op::identity{});
Khalique's avatar
Khalique committed
47
        add_generic_op("Identity", op::identity{});
Shucai Xiao's avatar
Shucai Xiao committed
48
49
50
        add_generic_op("Sin", op::sin{});
        add_generic_op("Cos", op::cos{});
        add_generic_op("Tan", op::tan{});
51
52
        add_generic_op("Sinh", op::sinh{});
        add_generic_op("Cosh", op::cosh{});
53
        add_generic_op("Tanh", op::tanh{});
54
55
56
        add_generic_op("Asin", op::asin{});
        add_generic_op("Acos", op::acos{});
        add_generic_op("Atan", op::atan{});
57
        add_generic_op("Sqrt", op::sqrt{});
Paul's avatar
Paul committed
58

Khalique's avatar
Khalique committed
59
60
61
62
        add_binary_op("Add", op::add{});
        add_binary_op("Div", op::div{});
        add_binary_op("Mul", op::mul{});
        add_binary_op("Sub", op::sub{});
Shucai Xiao's avatar
Shucai Xiao committed
63
        add_binary_op("Pow", op::pow{});
Khalique's avatar
Khalique committed
64

Khalique's avatar
Khalique committed
65
66
67
        add_variadic_op("Sum", op::add{});
        add_variadic_op("Max", op::max{});
        add_variadic_op("Min", op::min{});
Paul's avatar
Paul committed
68

69
70
        add_mem_op("ArgMax", &onnx_parser::parse_argmax);
        add_mem_op("ArgMin", &onnx_parser::parse_argmin);
71
        add_mem_op("Cast", &onnx_parser::parse_cast);
Khalique's avatar
Khalique committed
72
        add_mem_op("Clip", &onnx_parser::parse_clip);
Khalique's avatar
Khalique committed
73
        add_mem_op("LRN", &onnx_parser::parse_lrn);
Khalique's avatar
Khalique committed
74
        add_mem_op("ImageScaler", &onnx_parser::parse_imagescaler);
75
        add_mem_op("LeakyRelu", &onnx_parser::parse_leaky_relu);
Khalique's avatar
Khalique committed
76
        add_mem_op("Elu", &onnx_parser::parse_elu);
77
        add_mem_op("Expand", &onnx_parser::parse_expand);
Paul's avatar
Paul committed
78
79
        add_mem_op("Constant", &onnx_parser::parse_constant);
        add_mem_op("Conv", &onnx_parser::parse_conv);
Paul's avatar
Paul committed
80
81
        add_mem_op("MaxPool", &onnx_parser::parse_pooling);
        add_mem_op("AveragePool", &onnx_parser::parse_pooling);
82
83
        add_mem_op("GlobalMaxPool", &onnx_parser::parse_pooling);
        add_mem_op("GlobalAveragePool", &onnx_parser::parse_pooling);
Paul's avatar
Paul committed
84
        add_mem_op("Reshape", &onnx_parser::parse_reshape);
Paul's avatar
Paul committed
85
86
        add_mem_op("Flatten", &onnx_parser::parse_flatten);
        add_mem_op("Gemm", &onnx_parser::parse_gemm);
87
        add_mem_op("MatMul", &onnx_parser::parse_matmul);
88
        add_mem_op("BatchNormalization", &onnx_parser::parse_batchnorm);
Paul's avatar
Paul committed
89
        add_mem_op("Softmax", &onnx_parser::parse_softmax);
Shucai Xiao's avatar
Shucai Xiao committed
90
        add_mem_op("LogSoftmax", &onnx_parser::parse_logsoftmax);
91
92
93
        add_mem_op("Squeeze", &onnx_parser::parse_squeeze);
        add_mem_op("Unsqueeze", &onnx_parser::parse_unsqueeze);
        add_mem_op("Slice", &onnx_parser::parse_slice);
Scott Thornton's avatar
Scott Thornton committed
94
        add_mem_op("Concat", &onnx_parser::parse_concat);
95
96
97
        add_mem_op("Gather", &onnx_parser::parse_gather);
        add_mem_op("Shape", &onnx_parser::parse_shape);
        add_mem_op("ConstantFill", &onnx_parser::parse_constant_fill);
98
        add_mem_op("ConstantOfShape", &onnx_parser::parse_constant_of_shape);
Khalique's avatar
Khalique committed
99
        add_mem_op("Transpose", &onnx_parser::parse_transpose);
Shucai Xiao's avatar
Shucai Xiao committed
100
        add_mem_op("RNN", &onnx_parser::parse_rnn);
101
        add_mem_op("GRU", &onnx_parser::parse_gru);
Shucai Xiao's avatar
Shucai Xiao committed
102
        add_mem_op("LSTM", &onnx_parser::parse_lstm);
Khalique's avatar
Khalique committed
103
        add_mem_op("Pad", &onnx_parser::parse_pad);
Shucai Xiao's avatar
Shucai Xiao committed
104
105
        add_mem_op("ReduceSum", &onnx_parser::parse_reduce_oper<op::reduce_sum>);
        add_mem_op("ReduceMean", &onnx_parser::parse_reduce_oper<op::reduce_mean>);
106
107
108
109
110
111
112

        // init the activation function map
        init_actv_func();
    }

    void init_actv_func()
    {
113
114
115
116
117
118
        // Support name format of all lower case or the first letter capital
        map_actv_funcs.insert(std::make_pair("tanh", op::tanh{}));
        map_actv_funcs.insert(std::make_pair("relu", op::relu{}));
        map_actv_funcs.insert(std::make_pair("sigmoid", op::sigmoid{}));
        map_actv_funcs.insert(std::make_pair("leakyrelu", op::leaky_relu{}));
        map_actv_funcs.insert(std::make_pair("elu", op::elu{}));
Paul's avatar
Paul committed
119
120
121
122
    }

    template <class F>
    void add_op(std::string name, F f)
Paul's avatar
Paul committed
123
124
125
126
127
128
129
130
131
    {
        ops.emplace(name, [=](auto&&... xs) {
            return std::vector<instruction_ref>{f(std::forward<decltype(xs)>(xs)...)};
        });
    }

    // Multi output op
    template <class F>
    void add_multi_op(std::string name, F f)
Paul's avatar
Paul committed
132
133
134
135
136
137
138
    {
        ops.emplace(name, f);
    }

    template <class F>
    void add_mem_op(std::string name, F f)
    {
Paul's avatar
Paul committed
139
        add_op(name, [=](auto&&... xs) {
Paul's avatar
Paul committed
140
141
142
            return std::mem_fn(f)(*this, name, std::forward<decltype(xs)>(xs)...);
        });
    }
Khalique's avatar
Khalique committed
143

144
    template <class T>
Khalique's avatar
Khalique committed
145
    void add_binary_op(std::string name, T x)
146
    {
Paul's avatar
Paul committed
147
        add_op(name, [this, x](attribute_map attributes, std::vector<instruction_ref> args) {
Scott Thornton's avatar
Scott Thornton committed
148
            if(args.size() != 2)
Paul's avatar
Paul committed
149
                MIGRAPHX_THROW("binary operators should have 2 operands");
150
            if(contains(attributes, "broadcast") and contains(attributes, "axis"))
151
152
153
154
            {
                uint64_t broadcasted = parse_value(attributes.at("broadcast")).at<uint64_t>();
                if(broadcasted != 0)
                {
155
                    uint64_t axis = parse_value(attributes.at("axis")).at<uint64_t>();
Shucai Xiao's avatar
Shucai Xiao committed
156
157
                    auto l = prog.add_instruction(op::broadcast{axis, args[0]->get_shape().lens()},
                                                  args[1]);
158
159
                    return prog.add_instruction(x, args[0], l);
                }
160
                return prog.add_instruction(x, args);
161
            }
Paul's avatar
Paul committed
162
            else
163
            {
Khalique's avatar
Khalique committed
164
                return add_broadcastable_binary_op(args[0], args[1], x);
165
166
167
168
            }
        });
    }

Shucai Xiao's avatar
Shucai Xiao committed
169
170
    std::vector<std::size_t> compute_broadcasted_lens(std::vector<std::size_t> s0,
                                                      std::vector<std::size_t> s1)
171
172
173
174
175
176
177
178
179
180
181
182
183
    {
        // Example:
        // s0 = (3,2,4,5) and s1 = (2,1,1)
        //
        // In this case we need to broadcast (:,1,1) portion of
        // s1 plus broadcast the 1st dimension of s1
        // giving output_lens = (3,2,4,5)
        //
        // Another example:
        // s0 = (3,2,1,5) and s1 = (2,7,5)
        // In this case we need to broadcast the (:,:,1:,:) axis
        // of s0 plus the 1st dimension of s1 giving
        // output_lens = (3,2,7,5)
Shucai Xiao's avatar
Shucai Xiao committed
184
        if(s0.size() > s1.size())
185
186
187
188
189
190
        {
            s0.swap(s1);
        }

        std::vector<std::size_t> out_lens(s1);
        auto offset = s1.size() - s0.size();
Shucai Xiao's avatar
Shucai Xiao committed
191
192
193
194
        std::transform(s0.begin(),
                       s0.end(),
                       s1.begin() + offset,
                       out_lens.begin() + offset,
195
                       [&](auto a, auto b) {
Shucai Xiao's avatar
Shucai Xiao committed
196
                           if(a != b and a != 1 and b != 1)
197
                           {
Shucai Xiao's avatar
Shucai Xiao committed
198
199
200
201
202
203
                               MIGRAPHX_THROW("COMPUTE_BROADCASTLEN: shape {" +
                                              to_string_range(s0) + "} and {" +
                                              to_string_range(s1) + "} mismatch!");
                           }
                           return std::max(a, b);
                       });
204
205
206
207

        return out_lens;
    }

Khalique's avatar
Khalique committed
208
209
210
    template <class T>
    instruction_ref add_broadcastable_binary_op(instruction_ref arg0, instruction_ref arg1, T x)
    {
Khalique's avatar
Khalique committed
211
        if(arg0->get_shape().lens() != arg1->get_shape().lens())
Khalique's avatar
Khalique committed
212
213
        {
            // Get lengths for both arguments
Shucai Xiao's avatar
Shucai Xiao committed
214
215
            auto s0       = arg0->get_shape().lens();
            auto s1       = arg1->get_shape().lens();
216
            auto out_lens = compute_broadcasted_lens(s0, s1);
Shucai Xiao's avatar
Shucai Xiao committed
217
218
            auto l0       = prog.add_instruction(op::multibroadcast{out_lens}, arg0);
            auto l1       = prog.add_instruction(op::multibroadcast{out_lens}, arg1);
Khalique's avatar
Khalique committed
219
220
221
222
223
224
            return prog.add_instruction(x, l0, l1);
        }
        else
        {
            return prog.add_instruction(x, {arg0, arg1});
        }
225
226
    }

Paul's avatar
Paul committed
227
    template <class T>
Paul's avatar
Paul committed
228
229
    void add_generic_op(std::string name, T x)
    {
Paul's avatar
Paul committed
230
        add_op(name, [this, x](const attribute_map&, std::vector<instruction_ref> args) {
Paul's avatar
Paul committed
231
232
233
234
            return prog.add_instruction(x, args);
        });
    }

Khalique's avatar
Khalique committed
235
    template <class T>
Khalique's avatar
Khalique committed
236
    void add_variadic_op(std::string name, T x)
Khalique's avatar
Khalique committed
237
    {
Paul's avatar
Paul committed
238
        add_op(name, [this, x](const attribute_map&, std::vector<instruction_ref> args) {
Khalique's avatar
Khalique committed
239
            return std::accumulate(std::next(args.begin()),
Khalique's avatar
Khalique committed
240
241
242
243
244
                                   args.end(),
                                   args.front(),
                                   [this, x](instruction_ref a, instruction_ref b) {
                                       return add_broadcastable_binary_op(a, b, x);
                                   });
Khalique's avatar
Khalique committed
245
        });
Khalique's avatar
Khalique committed
246
247
    }

Khalique's avatar
Khalique committed
248
249
250
    instruction_ref parse_clip(const std::string&,
                               const attribute_map& attributes,
                               std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
251
252
253
254
255
256
257
258
259
260
261
262
263
    {
        op::clip op;
        if(contains(attributes, "max"))
        {
            op.max_val = parse_value(attributes.at("max")).at<float>();
        }
        if(contains(attributes, "min"))
        {
            op.min_val = parse_value(attributes.at("min")).at<float>();
        }
        return prog.add_instruction(op, std::move(args));
    }

264
    instruction_ref parse_softmax(const std::string&,
Shucai Xiao's avatar
Shucai Xiao committed
265
266
                                  const attribute_map& attributes,
                                  std::vector<instruction_ref> args)
Paul's avatar
Paul committed
267
    {
268
269
270
271
272
273
274
        int axis = 1;
        if(contains(attributes, "axis"))
        {
            axis = parse_value(attributes.at("axis")).at<int>();
        }

        return prog.add_instruction(op::softmax{axis}, std::move(args));
Paul's avatar
Paul committed
275
276
    }

Shucai Xiao's avatar
Shucai Xiao committed
277
278
279
    instruction_ref parse_logsoftmax(const std::string&,
                                     const attribute_map& attributes,
                                     std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
280
281
282
283
284
285
286
287
288
289
    {
        int axis = 1;
        if(contains(attributes, "axis"))
        {
            axis = parse_value(attributes.at("axis")).at<int>();
        }

        return prog.add_instruction(op::logsoftmax{axis}, std::move(args));
    }

290
    instruction_ref parse_argmax(const std::string&,
Shucai Xiao's avatar
Shucai Xiao committed
291
292
                                 const attribute_map& attributes,
                                 std::vector<instruction_ref> args)
293
    {
294
        int64_t axis = 0;
295
296
        if(contains(attributes, "axis"))
        {
297
            axis = static_cast<int64_t>(parse_value(attributes.at("axis")).at<int>());
298
299
        }

Shucai Xiao's avatar
Shucai Xiao committed
300
        int keep_dims = 1;
Shucai Xiao's avatar
Shucai Xiao committed
301
        if(contains(attributes, "keepdims"))
Shucai Xiao's avatar
Shucai Xiao committed
302
303
304
305
        {
            keep_dims = parse_value(attributes.at("keepdims")).at<int>();
        }

Shucai Xiao's avatar
Shucai Xiao committed
306
        if(keep_dims == 0)
307
308
        {
            auto ins = prog.add_instruction(op::argmax{axis}, std::move(args));
309
            return prog.add_instruction(op::squeeze{{axis}}, ins);
310
311
312
313
314
        }
        else
        {
            return prog.add_instruction(op::argmax{axis}, std::move(args));
        }
315
316
317
    }

    instruction_ref parse_argmin(const std::string&,
Shucai Xiao's avatar
Shucai Xiao committed
318
319
                                 const attribute_map& attributes,
                                 std::vector<instruction_ref> args)
320
    {
321
        int64_t axis = 0;
322
323
        if(contains(attributes, "axis"))
        {
324
            axis = static_cast<int64_t>(parse_value(attributes.at("axis")).at<int>());
325
326
        }

Shucai Xiao's avatar
Shucai Xiao committed
327
        int keep_dims = 1;
Shucai Xiao's avatar
Shucai Xiao committed
328
        if(contains(attributes, "keepdims"))
Shucai Xiao's avatar
Shucai Xiao committed
329
330
331
332
        {
            keep_dims = parse_value(attributes.at("keepdims")).at<int>();
        }

Shucai Xiao's avatar
Shucai Xiao committed
333
        if(keep_dims == 0)
334
335
        {
            auto ins = prog.add_instruction(op::argmin{axis}, std::move(args));
336
            return prog.add_instruction(op::squeeze{{axis}}, ins);
337
338
339
340
341
        }
        else
        {
            return prog.add_instruction(op::argmin{axis}, std::move(args));
        }
342
343
    }

Paul's avatar
Paul committed
344
    instruction_ref
Paul's avatar
Paul committed
345
    parse_conv(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
346
    {
347
        op::convolution op;
348
        auto l0 = args[0];
Paul's avatar
Paul committed
349
350
        if(contains(attributes, "pads"))
        {
Scott Thornton's avatar
Scott Thornton committed
351
            if(contains(attributes, "auto_pad"))
352
            {
Paul's avatar
Paul committed
353
                MIGRAPHX_THROW("auto_pad and padding cannot be specified simultaneously");
354
            }
355
356
            std::vector<std::int64_t> padding;
            copy(attributes["pads"].ints(), std::back_inserter(padding));
Scott Thornton's avatar
Scott Thornton committed
357
            if(padding.size() != 4)
358
            {
Paul's avatar
Paul committed
359
                MIGRAPHX_THROW("padding should have 4 values");
360
            }
Scott Thornton's avatar
Scott Thornton committed
361
            if(padding[0] != padding[2] || padding[1] != padding[3])
362
            {
363
364
                // insert zeros for pad op (args[0] has 4 dims)
                padding = {0, 0, padding[0], padding[1], 0, 0, padding[2], padding[3]};
Khalique's avatar
Khalique committed
365
                l0      = prog.add_instruction(op::pad{padding}, l0);
366
            }
367
368
369
370
            else
            {
                op.padding[0] = padding[0];
                op.padding[1] = padding[1];
371
            }
Paul's avatar
Paul committed
372
        }
Paul's avatar
Paul committed
373
374
375
376
377
378
379
380
        if(contains(attributes, "strides"))
        {
            copy(attributes["strides"].ints(), op.stride.begin());
        }
        if(contains(attributes, "dilations"))
        {
            copy(attributes["dilations"].ints(), op.dilation.begin());
        }
Scott Thornton's avatar
Scott Thornton committed
381
        if(contains(attributes, "auto_pad"))
382
383
        {
            auto s = attributes["auto_pad"].s();
Scott Thornton's avatar
Scott Thornton committed
384
            if(contains(attributes, "pads") and to_upper(s) != "NOTSET")
385
            {
Paul's avatar
Paul committed
386
                MIGRAPHX_THROW("auto_pad and padding cannot be specified simultaneously");
387
388
            }

wsttiger's avatar
fixes  
wsttiger committed
389
            if(s.find("SAME") != std::string::npos)
390
            {
391
                op.padding_mode = op::padding_mode_t::same;
392
393
            }
        }
Khalique's avatar
Khalique committed
394
395
396
397
        if(contains(attributes, "group"))
        {
            op.group = parse_value(attributes.at("group")).at<int>();
        }
Paul's avatar
Paul committed
398
399
400
401
        if(args.size() == 3)
        {
            uint64_t axis = 1;
            auto l1       = prog.add_instruction(op, args[0], args[1]);
Shucai Xiao's avatar
Shucai Xiao committed
402
            auto l2 = prog.add_instruction(op::broadcast{axis, l1->get_shape().lens()}, args[2]);
403
            return prog.add_instruction(op::add{}, l1, l2);
Paul's avatar
Paul committed
404
        }
405
        return prog.add_instruction(op, l0, args[1]);
Paul's avatar
Paul committed
406
    }
Paul's avatar
Paul committed
407

Paul's avatar
Paul committed
408
409
410
    instruction_ref parse_pooling(const std::string& name,
                                  attribute_map attributes,
                                  std::vector<instruction_ref> args)
Paul's avatar
Paul committed
411
    {
Khalique's avatar
Khalique committed
412
        op::pooling op{ends_with(name, "MaxPool") ? "max" : "average"};
413
        auto l0 = args[0];
Khalique's avatar
Khalique committed
414
        if(starts_with(name, "Global"))
415
        {
Khalique's avatar
Khalique committed
416
417
            auto lens  = args.front()->get_shape().lens();
            op.lengths = {lens[2], lens[3]};
418
        }
Paul's avatar
Paul committed
419
420
        if(contains(attributes, "pads"))
        {
421
422
            std::vector<std::int64_t> padding;
            copy(attributes["pads"].ints(), std::back_inserter(padding));
Scott Thornton's avatar
Scott Thornton committed
423
            if(padding.size() != 4)
424
            {
Paul's avatar
Paul committed
425
                MIGRAPHX_THROW("padding should have 4 values");
426
            }
Scott Thornton's avatar
Scott Thornton committed
427
            if(padding[0] != padding[2] || padding[1] != padding[3])
428
            {
429
430
                // insert zeros for pad op (args[0] has 4 dims)
                padding = {0, 0, padding[0], padding[1], 0, 0, padding[2], padding[3]};
Khalique's avatar
Khalique committed
431
432
                l0 = prog.add_instruction(op::pad{padding, std::numeric_limits<float>::lowest()},
                                          l0);
433
434
435
436
437
            }
            else
            {
                op.padding[0] = padding[0];
                op.padding[1] = padding[1];
438
            }
Paul's avatar
Paul committed
439
440
441
442
443
444
445
446
447
        }
        if(contains(attributes, "strides"))
        {
            copy(attributes["strides"].ints(), op.stride.begin());
        }
        if(contains(attributes, "kernel_shape"))
        {
            copy(attributes["kernel_shape"].ints(), op.lengths.begin());
        }
Scott Thornton's avatar
Scott Thornton committed
448
        if(contains(attributes, "auto_pad"))
449
450
        {
            auto s = attributes["auto_pad"].s();
451
            if(s.find("SAME_UPPER") == std::string::npos)
452
            {
453
                MIGRAPHX_THROW("auto_pad only supports SAME_UPPER for pooling");
454
            }
455
            op.padding_mode = op::padding_mode_t::same;
456
457
        }

458
        return prog.add_instruction(op, l0);
Paul's avatar
Paul committed
459
460
    }

Paul's avatar
Paul committed
461
    instruction_ref
Paul's avatar
Paul committed
462
    parse_reshape(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
463
    {
464
        op::reshape op;
Paul's avatar
Paul committed
465
466
        if(args.size() == 1)
        {
Shucai Xiao's avatar
Shucai Xiao committed
467
            if(contains(attributes, "shape"))
468
469
470
471
472
473
            {
                literal s = parse_value(attributes.at("shape"));
                s.visit([&](auto v) { copy(v, std::back_inserter(op.dims)); });
            }
            else
            {
Shucai Xiao's avatar
Shucai Xiao committed
474
475
476
                MIGRAPHX_THROW(
                    "Parse_reshape: shape attribute is needed when only one argument is provided!");
            }
Paul's avatar
Paul committed
477
478
479
        }
        if(args.size() == 2)
        {
Paul's avatar
Paul committed
480
            auto s = args[1]->eval();
Paul's avatar
Paul committed
481
            if(s.empty())
Paul's avatar
Paul committed
482
                MIGRAPHX_THROW("Dynamic shape is not supported.");
Paul's avatar
Paul committed
483
            s.visit([&](auto v) { copy(v, std::back_inserter(op.dims)); });
Paul's avatar
Paul committed
484
        }
485

Shucai Xiao's avatar
Shucai Xiao committed
486
        if(!args[0]->get_shape().standard())
487
488
489
490
        {
            args[0] = prog.add_instruction(op::contiguous{}, args[0]);
        }

Paul's avatar
Paul committed
491
492
493
        return prog.add_instruction(op, args[0]);
    }

Paul's avatar
Paul committed
494
    instruction_ref
Paul's avatar
Paul committed
495
    parse_flatten(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
496
    {
497
        uint64_t axis = 1;
Paul's avatar
Paul committed
498
499
500
501
        if(contains(attributes, "axis"))
        {
            axis = parse_value(attributes.at("axis")).at<int>();
        }
502
        return prog.add_instruction(op::flatten{axis}, args[0]);
Paul's avatar
Paul committed
503
504
    }

505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
    instruction_ref
    parse_squeeze(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
        op::squeeze op;
        literal s = parse_value(attributes.at("axes"));
        s.visit([&](auto v) { copy(v, std::back_inserter(op.axes)); });
        return prog.add_instruction(op, args[0]);
    }

    instruction_ref
    parse_unsqueeze(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
        op::unsqueeze op;
        literal s = parse_value(attributes.at("axes"));
        s.visit([&](auto v) { copy(v, std::back_inserter(op.axes)); });
        return prog.add_instruction(op, args[0]);
    }

Scott Thornton's avatar
Scott Thornton committed
523
524
525
526
527
528
529
    instruction_ref
    parse_concat(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
        std::size_t axis = parse_value(attributes.at("axis")).at<int>();
        op::concat op{axis};
        return prog.add_instruction(op, std::move(args));
    }
530

531
532
533
    instruction_ref
    parse_gather(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
534
        int axis = 0;
535
536
537
538
        if(contains(attributes, "axis"))
        {
            axis = parse_value(attributes.at("axis")).at<int>();
        }
539
        op::gather op{axis};
540
541
542
        return prog.add_instruction(op, std::move(args));
    }

543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
    instruction_ref
    parse_slice(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
        op::slice op;
        if(contains(attributes, "axes"))
        {
            literal s = parse_value(attributes.at("axes"));
            s.visit([&](auto v) { copy(v, std::back_inserter(op.axes)); });
        }
        {
            literal s = parse_value(attributes.at("ends"));
            s.visit([&](auto v) { copy(v, std::back_inserter(op.ends)); });
        }
        {
            literal s = parse_value(attributes.at("starts"));
            s.visit([&](auto v) { copy(v, std::back_inserter(op.starts)); });
        }
        return prog.add_instruction(op, args[0]);
    }

Paul's avatar
Paul committed
563
564
565
    instruction_ref parse_constant(const std::string&,
                                   attribute_map attributes,
                                   const std::vector<instruction_ref>&)
Paul's avatar
Paul committed
566
    {
Shucai Xiao's avatar
Shucai Xiao committed
567
        literal v = parse_value(attributes.at("value"));
568
        // return empty literal
Shucai Xiao's avatar
Shucai Xiao committed
569
        if(v.get_shape().elements() == 0)
570
571
572
573
        {
            return prog.add_literal(literal{});
        }

574
575
576
        auto dim_size = attributes.at("value").t().dims_size();
        // if dim_size is 0, it is a scalar
        if(dim_size == 0)
577
        {
578
            migraphx::shape scalar_shape{v.get_shape().type()};
579
580
581
            return prog.add_literal(migraphx::literal{scalar_shape, v.data()});
        }

Paul's avatar
Paul committed
582
583
        return prog.add_literal(v);
    }
Paul's avatar
Paul committed
584

Paul's avatar
Paul committed
585
    instruction_ref
Paul's avatar
Paul committed
586
    parse_gemm(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
587
588
    {
        float alpha = 1.0f;
Khalique's avatar
Khalique committed
589
        float beta  = 1.0f;
Paul's avatar
Paul committed
590
591
592
593
594
595
596
597
        bool transa = false;
        bool transb = false;
        if(contains(attributes, "alpha"))
        {
            alpha = parse_value(attributes.at("alpha")).at<float>();
        }
        if(contains(attributes, "beta"))
        {
598
            beta = parse_value(attributes.at("beta")).at<float>();
Paul's avatar
Paul committed
599
600
601
602
603
604
605
606
607
        }
        if(contains(attributes, "transA"))
        {
            transa = parse_value(attributes.at("transA")).at<bool>();
        }
        if(contains(attributes, "transB"))
        {
            transb = parse_value(attributes.at("transB")).at<bool>();
        }
608
609
610
611
612
613

        std::vector<int64_t> perm(args[0]->get_shape().lens().size());
        std::iota(perm.begin(), perm.end(), int64_t{0});
        // swap the last two elements
        std::swap(*perm.rbegin(), *(perm.rbegin() + 1));

614
615
        auto l1 = (transa) ? prog.add_instruction(op::transpose{perm}, args[0]) : args[0];
        auto l2 = (transb) ? prog.add_instruction(op::transpose{perm}, args[1]) : args[1];
Paul's avatar
Paul committed
616
617
        if(args.size() == 3)
        {
618
            if(beta != 0.f && args[2]->get_shape().elements() > 0)
619
            {
Shucai Xiao's avatar
Shucai Xiao committed
620
                auto out_lens   = l1->get_shape().lens();
621
                out_lens.back() = l2->get_shape().lens().back();
Shucai Xiao's avatar
Shucai Xiao committed
622
                auto l3         = args[2];
Shucai Xiao's avatar
Shucai Xiao committed
623
624
                auto l3_lens    = l3->get_shape().lens();
                if(!std::equal(out_lens.begin(), out_lens.end(), l3_lens.begin(), l3_lens.end()))
Khalique's avatar
Khalique committed
625
                {
626
                    l3 = prog.add_instruction(op::multibroadcast{out_lens}, args[2]);
Khalique's avatar
Khalique committed
627
                }
628
                return prog.add_instruction(op::dot{alpha, beta}, l1, l2, l3);
629
            }
Paul's avatar
Paul committed
630
        }
631
632

        return prog.add_instruction(op::dot{alpha, beta}, l1, l2);
Paul's avatar
Paul committed
633
634
    }

635
    instruction_ref
Shucai Xiao's avatar
Shucai Xiao committed
636
    parse_matmul(const std::string&, const attribute_map&, std::vector<instruction_ref> args)
637
    {
Shucai Xiao's avatar
Shucai Xiao committed
638
639
        auto l0      = args[0];
        auto l1      = args[1];
640
641
642
643
644
        auto l0_lens = l0->get_shape().lens();
        auto l1_lens = l1->get_shape().lens();

        // args[0] is a vector, prepend 1 to the shape
        bool is_a_prepended = false;
Shucai Xiao's avatar
Shucai Xiao committed
645
        if(l0_lens.size() == 1)
646
647
648
649
650
651
652
        {
            is_a_prepended = true;
            l0_lens.insert(l0_lens.begin(), 1);
            l0 = prog.add_instruction(op::unsqueeze{{0}}, args[0]);
        }

        bool is_b_appended = false;
Shucai Xiao's avatar
Shucai Xiao committed
653
        if(l1_lens.size() == 1)
654
655
656
657
658
659
660
661
        {
            is_b_appended = true;
            l1_lens.push_back(1);
            l1 = prog.add_instruction(op::unsqueeze{{1}}, args[1]);
        }

        instruction_ref bl0 = l0;
        instruction_ref bl1 = l1;
Shucai Xiao's avatar
Shucai Xiao committed
662
        if(!std::equal(l0_lens.rbegin() + 2, l0_lens.rend(), l1_lens.rbegin() + 2, l1_lens.rend()))
663
664
665
666
667
668
        {
            auto l0_it = l0_lens.begin() + l0_lens.size() - 2;
            std::vector<std::size_t> l0_broadcasted_lens(l0_lens.begin(), l0_it);
            auto l1_it = l1_lens.begin() + l1_lens.size() - 2;
            std::vector<std::size_t> l1_broadcasted_lens(l1_lens.begin(), l1_it);
            auto output_lens = compute_broadcasted_lens(l0_broadcasted_lens, l1_broadcasted_lens);
669
            l0_broadcasted_lens = output_lens;
670
            l0_broadcasted_lens.insert(l0_broadcasted_lens.end(), l0_it, l0_lens.end());
671
            l1_broadcasted_lens = output_lens;
672
            l1_broadcasted_lens.insert(l1_broadcasted_lens.end(), l1_it, l1_lens.end());
Shucai Xiao's avatar
Shucai Xiao committed
673
            if(l0_lens != l0_broadcasted_lens)
674
675
676
            {
                bl0 = prog.add_instruction(op::multibroadcast{l0_broadcasted_lens}, l0);
            }
Shucai Xiao's avatar
Shucai Xiao committed
677
            if(l1_lens != l1_broadcasted_lens)
678
679
680
681
682
            {
                bl1 = prog.add_instruction(op::multibroadcast{l1_broadcasted_lens}, l1);
            }
        }

Shucai Xiao's avatar
Shucai Xiao committed
683
        auto dot_res     = prog.add_instruction(op::dot{1.0f, 0.0f}, bl0, bl1);
684
        int64_t num_axis = static_cast<int64_t>(dot_res->get_shape().lens().size());
Shucai Xiao's avatar
Shucai Xiao committed
685
        if(is_a_prepended)
686
687
688
689
        {
            dot_res = prog.add_instruction(op::squeeze{{num_axis - 2}}, dot_res);
            --num_axis;
        }
Shucai Xiao's avatar
Shucai Xiao committed
690
        if(is_b_appended)
691
692
693
        {
            dot_res = prog.add_instruction(op::squeeze{{num_axis - 1}}, dot_res);
        }
Shucai Xiao's avatar
Shucai Xiao committed
694

695
696
697
        return dot_res;
    }

698
    instruction_ref
Paul's avatar
Paul committed
699
    parse_batchnorm(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
700
    {
Scott Thornton's avatar
Scott Thornton committed
701
702
        float epsilon                                     = 1e-5f;
        float momentum                                    = 0.9f;
703
        op::batch_norm_inference::bn_infer_mode_t bn_mode = op::batch_norm_inference::spatial;
Scott Thornton's avatar
Scott Thornton committed
704
        bool is_test                                      = false;
705
706
707
708
709
710
        if(contains(attributes, "epsilon"))
        {
            epsilon = parse_value(attributes.at("epsilon")).at<float>();
        }
        if(contains(attributes, "momentum"))
        {
711
            momentum = parse_value(attributes.at("momentum")).at<float>();
712
713
714
        }
        if(contains(attributes, "is_test"))
        {
wsttiger's avatar
wsttiger committed
715
            is_test = parse_value(attributes.at("is_test")).at<uint64_t>() > 0;
716
717
718
        }
        if(contains(attributes, "spatial"))
        {
719
            bn_mode = (parse_value(attributes.at("spatial")).at<uint64_t>() > 0)
720
721
                          ? op::batch_norm_inference::spatial
                          : op::batch_norm_inference::per_activation;
722
        }
Paul's avatar
Paul committed
723
        (void)is_test;
Paul's avatar
Paul committed
724
        op::batch_norm_inference op{epsilon, momentum, bn_mode};
Paul's avatar
Paul committed
725
        return prog.add_instruction(op, std::move(args));
726
727
    }

728
729
730
731
    instruction_ref parse_leaky_relu(const std::string&,
                                     attribute_map attributes,
                                     std::vector<instruction_ref> args)
    {
Khalique's avatar
Khalique committed
732
        float alpha = 0.01; // default alpha val for leaky relu
733
734
735
736
737
738
739
740
        if(contains(attributes, "alpha"))
        {
            alpha = parse_value(attributes.at("alpha")).at<float>();
        }
        op::leaky_relu op{alpha};
        return prog.add_instruction(op, args.front());
    }

Khalique's avatar
Khalique committed
741
742
    instruction_ref
    parse_elu(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
743
744
745
746
747
748
749
750
751
752
    {
        float alpha = 1.0; // default alpha val for elu
        if(contains(attributes, "alpha"))
        {
            alpha = parse_value(attributes.at("alpha")).at<float>();
        }
        op::elu op{alpha};
        return prog.add_instruction(op, args.front());
    }

Khalique's avatar
Khalique committed
753
754
    instruction_ref
    parse_lrn(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
755
756
    {
        float alpha = 0.0001;
Khalique's avatar
Khalique committed
757
758
759
        float beta  = 0.75;
        float bias  = 1.0;
        int size    = 1;
Khalique's avatar
Khalique committed
760
761
762
763
764
765
766
767
768
769
770
771
        if(contains(attributes, "alpha"))
            alpha = parse_value(attributes.at("alpha")).at<float>();
        if(contains(attributes, "beta"))
            beta = parse_value(attributes.at("beta")).at<float>();
        if(contains(attributes, "bias"))
            bias = parse_value(attributes.at("bias")).at<float>();
        if(contains(attributes, "size"))
            size = parse_value(attributes.at("size")).at<int>();
        op::lrn op{alpha, beta, bias, size};
        return prog.add_instruction(op, args.front());
    }

Khalique's avatar
Khalique committed
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
    instruction_ref parse_imagescaler(const std::string&,
                                      attribute_map attributes,
                                      std::vector<instruction_ref> args)
    {
        float scale = 1.0;
        std::vector<float> bias{};
        if(contains(attributes, "scale"))
        {
            scale = parse_value(attributes.at("scale")).at<float>();
        }

        if(contains(attributes, "bias"))
        {
            auto&& bias_floats = attributes["bias"].floats();
            bias               = std::vector<float>(bias_floats.begin(), bias_floats.end());
        }
788
        auto input_lens = args.front()->get_shape().lens();
Khalique's avatar
Khalique committed
789

Khalique's avatar
Khalique committed
790
791
        auto scale_val = prog.add_literal(scale);
        auto bias_vals = prog.add_literal(
Paul's avatar
Paul committed
792
            migraphx::literal{migraphx::shape{migraphx::shape::float_type, {bias.size()}}, bias});
Khalique's avatar
Khalique committed
793

794
        auto scale_tensor = prog.add_instruction(migraphx::op::scalar{input_lens}, scale_val);
Paul's avatar
Paul committed
795
        auto img_scaled   = prog.add_instruction(migraphx::op::mul{}, args.front(), scale_tensor);
Shucai Xiao's avatar
Shucai Xiao committed
796
        auto bias_bcast   = prog.add_instruction(migraphx::op::broadcast{1, input_lens}, bias_vals);
Paul's avatar
Paul committed
797
        return prog.add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);
Khalique's avatar
Khalique committed
798
    }
Khalique's avatar
Khalique committed
799

Khalique's avatar
Khalique committed
800
801
    instruction_ref
    parse_transpose(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
802
803
804
805
806
807
808
    {
        std::vector<int64_t> perm{};
        if(contains(attributes, "perm"))
        {
            auto&& perm_vals = attributes["perm"].ints();
            perm             = std::vector<int64_t>(perm_vals.begin(), perm_vals.end());
        }
Paul's avatar
Paul committed
809
        return prog.add_instruction(migraphx::op::transpose{perm}, args.front());
Khalique's avatar
Khalique committed
810
811
    }

Khalique's avatar
Khalique committed
812
813
814
815
816
817
818
819
820
821
    instruction_ref
    parse_pad(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
        std::vector<int64_t> pads{};
        float value = 0.0f;
        if(contains(attributes, "pads"))
        {
            auto&& pad_vals = attributes["pads"].ints();
            pads            = std::vector<int64_t>(pad_vals.begin(), pad_vals.end());
        }
822
        // check if padding is actually being done (at least one value is nonzero)
Khalique's avatar
Khalique committed
823
        if(std::all_of(pads.begin(), pads.end(), [](const int& i) { return i == 0; }))
824
825
826
        {
            return prog.add_instruction(migraphx::op::identity{}, args.front());
        }
Khalique's avatar
Khalique committed
827
828
829
830
831
832
833
834
835
836
837
838
        if(contains(attributes, "value"))
        {
            value = parse_value(attributes.at("value")).at<float>();
        }
        if(contains(attributes, "mode"))
        {
            auto mode = attributes.at("mode").s();
            if(mode != "constant")
                MIGRAPHX_THROW("migraphx currently only supports constant padding");
        }
        return prog.add_instruction(migraphx::op::pad{pads, value}, args.front());
    }
839
840
841
    // Use a literal instruction to replace the shape since, output of
    // shape operator are literals in migraphx
    instruction_ref
Shucai Xiao's avatar
Shucai Xiao committed
842
    parse_shape(const std::string&, const attribute_map&, std::vector<instruction_ref> args)
843
844
    {
        if(args.size() != 1)
845
            MIGRAPHX_THROW("Shape: operator should have 1 operand");
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
        std::vector<std::size_t> arg_shape = args[0]->get_shape().lens();
        std::vector<int64_t> vec_shape(arg_shape.size());
        migraphx::shape s(migraphx::shape::int64_type, {arg_shape.size()});
        std::transform(arg_shape.begin(), arg_shape.end(), vec_shape.begin(), [](auto i) {
            return int64_t(i);
        });
        return prog.add_literal(migraphx::literal{s, vec_shape});
    }

    // Use a literal instruction to replace the constantFill operator. In RNN, input shape
    // and value are fixed, so no need to do the actual computation for the constantFill
    // operator
    instruction_ref parse_constant_fill(const std::string&,
                                        attribute_map attributes,
                                        std::vector<instruction_ref> args)
    {
        int input_as_shape = 0;
        int dtype          = 1;
        float value        = 0.0f;

        if(contains(attributes, "dtype"))
        {
            dtype = parse_value(attributes.at("dtype")).at<int>();
        }
        migraphx::shape::type_t type = get_type(dtype);

        if(contains(attributes, "input_as_shape"))
        {
            input_as_shape = parse_value(attributes.at("input_as_shape")).at<int>();
        }

        if(contains(attributes, "value"))
        {
            value = parse_value(attributes.at("value")).at<float>();
        }

Shucai Xiao's avatar
Shucai Xiao committed
882
883
        if(contains(attributes, "extra_shape"))
        {
884
            MIGRAPHX_THROW("ConstantFill: cannot handle extra shape attribute");
885
886
        }

887
888
        if(input_as_shape == 1)
        {
Shucai Xiao's avatar
Shucai Xiao committed
889
            if(args.size() != 1)
890
            {
891
                MIGRAPHX_THROW("ConstantFill: need an input argument as output shape");
892
893
            }

Shucai Xiao's avatar
Shucai Xiao committed
894
895
            if(contains(attributes, "shape"))
            {
896
                MIGRAPHX_THROW("ConstantFill: cannot set the shape argument and pass in an input "
Shucai Xiao's avatar
Shucai Xiao committed
897
                               "at the same time");
898
899
            }

900
901
902
            migraphx::argument in = args[0]->eval();
            if(in.empty())
            {
903
                MIGRAPHX_THROW("ConstantFill: cannot handle dynamic shape as input");
904
            }
905

906
907
908
            std::vector<std::size_t> dims;
            in.visit([&](auto input) { dims.assign(input.begin(), input.end()); });
            migraphx::shape s(type, dims);
909
910
            std::vector<float> values(s.elements(), value);
            return prog.add_literal(migraphx::literal(s, values));
911
912
913
        }
        else if(input_as_shape == 0)
        {
Shucai Xiao's avatar
Shucai Xiao committed
914
915
            if(!contains(attributes, "shape"))
            {
916
                MIGRAPHX_THROW("ConstantFill: attribute output shape is needed");
917
918
919
            }

            literal ls = parse_value(attributes.at("shape"));
920
            std::vector<std::size_t> dims;
Shucai Xiao's avatar
Shucai Xiao committed
921
            ls.visit([&](auto s) { dims.assign(s.begin(), s.end()); });
922
            migraphx::shape s{type, dims};
923
924
            std::vector<float> values(s.elements(), value);
            return prog.add_literal(migraphx::literal(s, values));
925
926
927
        }
        else
        {
928
            MIGRAPHX_THROW("ConstantFill: wrong value of attribute input_as_shape");
929
930
931
        }
    }

Shucai Xiao's avatar
Shucai Xiao committed
932
933
934
    instruction_ref parse_constant_of_shape(const std::string&,
                                            attribute_map attributes,
                                            std::vector<instruction_ref> args)
935
936
    {
        literal l_val{};
Shucai Xiao's avatar
Shucai Xiao committed
937
        if(contains(attributes, "value"))
938
939
        {
            l_val = parse_value(attributes.at("value"));
Shucai Xiao's avatar
Shucai Xiao committed
940
            if(l_val.get_shape().elements() != 1)
941
942
943
944
945
946
947
948
949
950
951
            {
                MIGRAPHX_THROW("ConstantOfShape: attribute value can contain only 1 elements!");
            }
        }
        else
        {
            l_val = literal({shape::float_type, {1}, {0}}, {0.0f});
        }

        // input is empty, output is a scalar
        auto type = l_val.get_shape().type();
952

Shucai Xiao's avatar
Shucai Xiao committed
953
        if(args.empty())
954
        {
955
            MIGRAPHX_THROW("Parse ConstantOfShape : must have 1 input!");
956
957
958
        }
        else
        {
959
960
            migraphx::shape s;
            // empty input tensor, output is a scalar
Shucai Xiao's avatar
Shucai Xiao committed
961
            if(args[0]->get_shape().elements() == 0)
962
            {
963
                s = migraphx::shape{type, {1}, {0}};
964
            }
965
966
967
968
969
970
971
            else
            {
                migraphx::argument in = args[0]->eval();
                if(in.empty())
                {
                    MIGRAPHX_THROW("Parse ConstantOfShape: cannot handle dynamic shape as input");
                }
972

973
974
975
976
                std::vector<std::size_t> dims;
                in.visit([&](auto input) { dims.assign(input.begin(), input.end()); });
                s = migraphx::shape{type, dims};
            }
977
978
979
980
981
982
983
984
985
986
987
988
989

            literal l_out;
            l_val.visit([&](auto val) {
                using type = std::remove_cv_t<typename decltype(val)::value_type>;
                // l_val contains only one element
                std::vector<type> out_vec(s.elements(), *val.begin());
                l_out = literal(s, out_vec);
            });

            return prog.add_literal(l_out);
        }
    }

Shucai Xiao's avatar
Shucai Xiao committed
990
    instruction_ref
Shucai Xiao's avatar
Shucai Xiao committed
991
    parse_expand(const std::string&, const attribute_map&, std::vector<instruction_ref> args)
992
    {
Shucai Xiao's avatar
Shucai Xiao committed
993
        auto in_lens             = args[0]->get_shape().lens();
994
        migraphx::argument arg_s = args[1]->eval();
Shucai Xiao's avatar
Shucai Xiao committed
995
        if(arg_s.empty())
996
997
998
999
1000
1001
        {
            MIGRAPHX_THROW("Parse Expand: cannot handle dynamic shape as input");
        }
        std::vector<std::size_t> dims;
        arg_s.visit([&](auto input) { dims.assign(input.begin(), input.end()); });
        auto out_lens = compute_broadcasted_lens(in_lens, dims);
Shucai Xiao's avatar
Shucai Xiao committed
1002
        return prog.add_instruction(op::multibroadcast{out_lens}, args[0]);
1003
1004
    }

Shucai Xiao's avatar
Shucai Xiao committed
1005
    std::vector<instruction_ref>
Shucai Xiao's avatar
Shucai Xiao committed
1006
1007
1008
    parse_rnn(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
        migraphx::shape input_shape = args[0]->get_shape();
1009
        std::size_t hidden_size     = args[1]->get_shape().lens()[1];
Shucai Xiao's avatar
Shucai Xiao committed
1010
1011
1012

        if(contains(attributes, "hidden_size"))
        {
Shucai Xiao's avatar
Shucai Xiao committed
1013
            std::size_t hidden_size_att = parse_value(attributes.at("hidden_size")).at<int>();
Shucai Xiao's avatar
Shucai Xiao committed
1014
            if(hidden_size != hidden_size_att)
Shucai Xiao's avatar
Shucai Xiao committed
1015
1016
1017
            {
                MIGRAPHX_THROW("RNN: hidden size mismatch in input and attribute");
            }
Shucai Xiao's avatar
Shucai Xiao committed
1018
1019
1020
1021
1022
1023
1024
1025
1026
        }

        // Handling of direction to be added later
        std::string direction{"forward"};
        if(contains(attributes, "direction"))
        {
            direction = attributes.at("direction").s();
        }

1027
        op::rnn_direction dirct = op::rnn_direction::forward;
Shucai Xiao's avatar
Shucai Xiao committed
1028
1029
        if(direction == "bidirectional")
        {
1030
            dirct = op::rnn_direction::bidirectional;
Shucai Xiao's avatar
Shucai Xiao committed
1031
1032
1033
        }
        else if(direction == "reverse")
        {
1034
            dirct = op::rnn_direction::reverse;
Shucai Xiao's avatar
Shucai Xiao committed
1035
1036
        }

1037
        std::vector<std::string> vec_names{"tanh"};
1038
1039
1040
1041
        if(contains(attributes, "activations"))
        {
            auto names = attributes.at("activations").strings();
            vec_names.clear();
1042
            vec_names.resize(names.size());
Shucai Xiao's avatar
Shucai Xiao committed
1043
1044
1045
            std::transform(names.begin(), names.end(), vec_names.begin(), [](auto name) {
                return to_lower(name);
            });
1046
1047
        }

1048
1049
1050
        auto name_it = std::find_if(vec_names.begin(), vec_names.end(), [&](auto& name) {
            return (map_actv_funcs.count(name) == 0);
        });
Shucai Xiao's avatar
Shucai Xiao committed
1051
        if(name_it != vec_names.end())
1052
1053
1054
        {
            MIGRAPHX_THROW("RNN: activation function " + std::string(*name_it) + " not supported");
        }
1055

Shucai Xiao's avatar
Shucai Xiao committed
1056
        // bidirectional case should have two activation functions.
Shucai Xiao's avatar
Shucai Xiao committed
1057
        // one is for forward, and the other is for reverse.
Shucai Xiao's avatar
Shucai Xiao committed
1058
        // if only one actv function is provided, we use it in both
1059
        // forward and reverse direction
1060
        if(dirct == op::rnn_direction::bidirectional)
1061
        {
Shucai Xiao's avatar
Shucai Xiao committed
1062
            if(vec_names.size() == 1)
1063
1064
1065
1066
1067
            {
                vec_names.push_back(vec_names.at(0));
            }
        }

Shucai Xiao's avatar
Shucai Xiao committed
1068
1069
1070
        std::vector<operation> vec_actv_funcs(vec_names.size());
        std::transform(vec_names.begin(), vec_names.end(), vec_actv_funcs.begin(), [&](auto& fn) {
            return map_actv_funcs[fn];
1071
        });
Shucai Xiao's avatar
Shucai Xiao committed
1072

Shucai Xiao's avatar
Shucai Xiao committed
1073
1074
1075
1076
1077
1078
1079
        // To be added later
        float clip = 0.0;
        if(contains(attributes, "clip"))
        {
            clip = parse_value(attributes.at("clip")).at<float>();
        }

1080
1081
        // if the number of arguments is less than 6, append
        // undefined operator to have 6 arguments
Shucai Xiao's avatar
Shucai Xiao committed
1082
        if(args.size() < 6)
1083
1084
1085
1086
1087
        {
            auto ins = prog.add_instruction(op::undefined{});
            args.insert(args.end(), (6 - args.size()), ins);
        }

Shucai Xiao's avatar
Shucai Xiao committed
1088
1089
        // first output for the concatenation of hidden states
        auto hidden_states = prog.add_instruction(op::rnn{hidden_size, vec_actv_funcs, dirct, clip},
Shucai Xiao's avatar
Shucai Xiao committed
1090
                                                  std::move(args));
Shucai Xiao's avatar
Shucai Xiao committed
1091

1092
        // second output for the last hidden state
Shucai Xiao's avatar
Shucai Xiao committed
1093
        auto last_output = prog.add_instruction(op::rnn_last_output{}, hidden_states);
Shucai Xiao's avatar
Shucai Xiao committed
1094

Shucai Xiao's avatar
Shucai Xiao committed
1095
        return {hidden_states, last_output};
Shucai Xiao's avatar
Shucai Xiao committed
1096
1097
    }

1098
    std::vector<instruction_ref>
1099
1100
1101
1102
1103
1104
1105
    parse_gru(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
        migraphx::shape input_shape = args[0]->get_shape();
        std::size_t hidden_size     = args[2]->get_shape().lens()[2];

        if(contains(attributes, "hidden_size"))
        {
Shucai Xiao's avatar
Shucai Xiao committed
1106
            std::size_t hidden_size_att = parse_value(attributes.at("hidden_size")).at<int>();
Shucai Xiao's avatar
Shucai Xiao committed
1107
            if(hidden_size != hidden_size_att)
Shucai Xiao's avatar
Shucai Xiao committed
1108
1109
1110
            {
                MIGRAPHX_THROW("GRU: hidden size mismatch in input and attribute");
            }
1111
1112
1113
1114
1115
1116
1117
1118
1119
        }

        // Handling of direction to be added later
        std::string direction{"forward"};
        if(contains(attributes, "direction"))
        {
            direction = attributes.at("direction").s();
        }

1120
        op::rnn_direction dirct = op::rnn_direction::forward;
1121
1122
        if(direction == "bidirectional")
        {
1123
            dirct = op::rnn_direction::bidirectional;
1124
1125
1126
        }
        else if(direction == "reverse")
        {
1127
            dirct = op::rnn_direction::reverse;
1128
1129
        }

1130
        std::vector<std::string> vec_names = {"sigmoid", "tanh"};
1131
1132
        if(contains(attributes, "activations"))
        {
1133
            auto names = attributes.at("activations").strings();
1134
            vec_names.clear();
Shucai Xiao's avatar
Shucai Xiao committed
1135
            vec_names.resize(names.size());
Shucai Xiao's avatar
Shucai Xiao committed
1136
1137
1138
            std::transform(names.begin(), names.end(), vec_names.begin(), [](auto name) {
                return to_lower(name);
            });
1139
1140
        }

1141
        // need 4 activation functions
1142
        if(dirct == op::rnn_direction::bidirectional)
1143
        {
Shucai Xiao's avatar
Shucai Xiao committed
1144
            // 4 activation functions are used in the bidirectional
1145
            // scenario. No spec is provided in onnx::operator. we
Shucai Xiao's avatar
Shucai Xiao committed
1146
1147
            // use the algorithm that: if 1 actv function is provided,
            // repeat 1 four times. If 2 actv functins are provided,
1148
1149
            // assume forward and reverse use the same pair of actv
            // functions. For the case of 3 actv functions provided,
Shucai Xiao's avatar
Shucai Xiao committed
1150
1151
1152
            // assume the 3rd one is repeated once and used by the
            // reverse direction.
            // This may need change later
1153
            if(vec_names.size() == 1)
1154
            {
1155
                vec_names.insert(vec_names.end(), 3, vec_names.at(0));
1156
            }
1157
            else if(vec_names.size() == 2)
1158
            {
1159
1160
1161
                // repeat the activation functions
                vec_names.push_back(vec_names.at(0));
                vec_names.push_back(vec_names.at(1));
1162
            }
1163
            else if(vec_names.size() == 3)
1164
            {
1165
                vec_names.push_back(vec_names.at(2));
1166
1167
            }
        }
Shucai Xiao's avatar
Shucai Xiao committed
1168
        else
1169
        {
1170
            if(vec_names.size() == 1)
1171
            {
1172
                vec_names.push_back(vec_names.at(0));
1173
1174
1175
            }
        }

1176
1177
1178
        auto name_it = std::find_if(vec_names.begin(), vec_names.end(), [&](auto& name) {
            return (map_actv_funcs.count(name) == 0);
        });
Shucai Xiao's avatar
Shucai Xiao committed
1179
        if(name_it != vec_names.end())
1180
1181
1182
        {
            MIGRAPHX_THROW("GRU: activation function " + std::string(*name_it) + " not supported");
        }
1183

Shucai Xiao's avatar
Shucai Xiao committed
1184
1185
1186
        std::vector<operation> vec_actv_funcs(vec_names.size());
        std::transform(vec_names.begin(), vec_names.end(), vec_actv_funcs.begin(), [&](auto& name) {
            return map_actv_funcs[name];
Shucai Xiao's avatar
Shucai Xiao committed
1187
        });
1188
1189
1190
1191
1192
1193
1194
1195

        float clip = 0.0;
        if(contains(attributes, "clip"))
        {
            clip = parse_value(attributes.at("clip")).at<float>();
        }

        int linear_before_reset = 0;
Shucai Xiao's avatar
Shucai Xiao committed
1196
        if(contains(attributes, "linear_before_reset"))
1197
1198
1199
1200
        {
            linear_before_reset = parse_value(attributes.at("linear_before_reset")).at<int>();
        }

Shucai Xiao's avatar
Shucai Xiao committed
1201
        // append undefined opeator to make 6 arguments
Shucai Xiao's avatar
Shucai Xiao committed
1202
        if(args.size() < 6)
Shucai Xiao's avatar
Shucai Xiao committed
1203
1204
1205
1206
1207
        {
            auto ins = prog.add_instruction(op::undefined{});
            args.insert(args.end(), 6 - args.size(), ins);
        }

1208
1209
        // first output for concatenation of hidden states
        auto hidden_states = prog.add_instruction(
Shucai Xiao's avatar
Shucai Xiao committed
1210
            op::gru{hidden_size, vec_actv_funcs, dirct, clip, linear_before_reset},
Shucai Xiao's avatar
Shucai Xiao committed
1211
            std::move(args));
1212
1213

        // second output for last gru output
1214
        auto last_output = prog.add_instruction(op::rnn_last_output{}, hidden_states);
1215

Shucai Xiao's avatar
Shucai Xiao committed
1216
        return {hidden_states, last_output};
1217
1218
    }

Shucai Xiao's avatar
Shucai Xiao committed
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
    std::vector<instruction_ref>
    parse_lstm(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
        migraphx::shape input_shape = args[0]->get_shape();
        std::size_t hidden_size     = args[2]->get_shape().lens()[2];

        if(contains(attributes, "hidden_size"))
        {
            std::size_t hidden_size_att = parse_value(attributes.at("hidden_size")).at<int>();
            if(hidden_size != hidden_size_att)
            {
                MIGRAPHX_THROW("LSTM: hidden size mismatch in input and attribute");
            }
        }

        // Handling of direction to be added later
        std::string direction{"forward"};
        if(contains(attributes, "direction"))
        {
            direction = attributes.at("direction").s();
        }

Shucai Xiao's avatar
Shucai Xiao committed
1241
        op::rnn_direction dirct = op::rnn_direction::forward;
Shucai Xiao's avatar
Shucai Xiao committed
1242
1243
        if(direction == "bidirectional")
        {
Shucai Xiao's avatar
Shucai Xiao committed
1244
            dirct = op::rnn_direction::bidirectional;
Shucai Xiao's avatar
Shucai Xiao committed
1245
1246
1247
        }
        else if(direction == "reverse")
        {
Shucai Xiao's avatar
Shucai Xiao committed
1248
            dirct = op::rnn_direction::reverse;
Shucai Xiao's avatar
Shucai Xiao committed
1249
        }
Shucai Xiao's avatar
Shucai Xiao committed
1250
        else if(direction == "forward")
Shucai Xiao's avatar
Shucai Xiao committed
1251
        {
Shucai Xiao's avatar
Shucai Xiao committed
1252
            dirct = op::rnn_direction::forward;
Shucai Xiao's avatar
Shucai Xiao committed
1253
1254
1255
1256
1257
1258
        }
        else
        {
            MIGRAPHX_THROW("LSTM: incorrect direction attribute");
        }

1259
        std::vector<std::string> vec_names = {"sigmoid", "tanh", "tanh"};
Shucai Xiao's avatar
Shucai Xiao committed
1260
1261
1262
1263
1264
        if(contains(attributes, "activations"))
        {
            auto names = attributes.at("activations").strings();
            vec_names.clear();
            vec_names.resize(names.size());
Shucai Xiao's avatar
Shucai Xiao committed
1265
1266
1267
            std::transform(names.begin(), names.end(), vec_names.begin(), [](auto name) {
                return to_lower(name);
            });
Shucai Xiao's avatar
Shucai Xiao committed
1268
1269
1270
        }

        // need 6 activation functions for bidirectional directions
Shucai Xiao's avatar
Shucai Xiao committed
1271
        if(dirct == op::rnn_direction::bidirectional)
Shucai Xiao's avatar
Shucai Xiao committed
1272
1273
1274
1275
1276
1277
        {
            // 6 activation functions are used in the bidirectional
            // scenario. No spec is provided in onnx::operator. we
            // use the algorithm that: if 1 actv function is provided,
            // repeat 1st six times. If 2 actv functins are provided,
            // repeat 2nd once, then repeat all three once
Shucai Xiao's avatar
Shucai Xiao committed
1278
            // if 3 actv funcs are provide, repeat all three once.
Shucai Xiao's avatar
Shucai Xiao committed
1279
1280
1281
1282
            // the same algorithm is used for 4, 5, and 6 actv funcions
            // provided. This may need change later
            switch(vec_names.size())
            {
1283
            case 1:
Shucai Xiao's avatar
Shucai Xiao committed
1284
1285
1286
1287
1288
1289
                vec_names = {vec_names.at(0),
                             vec_names.at(0),
                             vec_names.at(0),
                             vec_names.at(0),
                             vec_names.at(0),
                             vec_names.at(0)};
1290
                break;
Shucai Xiao's avatar
Shucai Xiao committed
1291
1292
1293

            case 2:
                // repeat the 2nd actv func once, then repeat all three another time
Shucai Xiao's avatar
Shucai Xiao committed
1294
1295
1296
1297
1298
1299
                vec_names = {vec_names.at(0),
                             vec_names.at(1),
                             vec_names.at(1),
                             vec_names.at(0),
                             vec_names.at(1),
                             vec_names.at(1)};
Shucai Xiao's avatar
Shucai Xiao committed
1300
1301
1302
1303
                break;

            case 3:
                // repeat all three actv funcs once
Shucai Xiao's avatar
Shucai Xiao committed
1304
1305
1306
1307
1308
1309
                vec_names = {vec_names.at(0),
                             vec_names.at(1),
                             vec_names.at(2),
                             vec_names.at(0),
                             vec_names.at(1),
                             vec_names.at(2)};
Shucai Xiao's avatar
Shucai Xiao committed
1310
1311
                break;

Shucai Xiao's avatar
Shucai Xiao committed
1312
1313
1314
1315
1316
1317
1318
            case 4:
                vec_names = {vec_names.at(0),
                             vec_names.at(1),
                             vec_names.at(2),
                             vec_names.at(3),
                             vec_names.at(3),
                             vec_names.at(3)};
1319
                break;
Shucai Xiao's avatar
Shucai Xiao committed
1320

Shucai Xiao's avatar
Shucai Xiao committed
1321
1322
1323
1324
1325
1326
1327
            case 5:
                vec_names = {vec_names.at(0),
                             vec_names.at(1),
                             vec_names.at(2),
                             vec_names.at(3),
                             vec_names.at(4),
                             vec_names.at(4)};
1328
                break;
Shucai Xiao's avatar
Shucai Xiao committed
1329

Shucai Xiao's avatar
Shucai Xiao committed
1330
            default: break;
Shucai Xiao's avatar
Shucai Xiao committed
1331
1332
1333
1334
1335
1336
            }
        }
        else
        {
            switch(vec_names.size())
            {
Shucai Xiao's avatar
Shucai Xiao committed
1337
            case 1: vec_names = {vec_names.at(0), vec_names.at(0), vec_names.at(0)}; break;
Shucai Xiao's avatar
Shucai Xiao committed
1338
1339
1340

            case 2:
                // repeat the 2nd actv func once, so we have 3 actv funcs
Shucai Xiao's avatar
Shucai Xiao committed
1341
                vec_names = {vec_names.at(0), vec_names.at(1), vec_names.at(1)};
Shucai Xiao's avatar
Shucai Xiao committed
1342
1343
                break;

Shucai Xiao's avatar
Shucai Xiao committed
1344
            default: break;
Shucai Xiao's avatar
Shucai Xiao committed
1345
1346
1347
            }
        }

1348
1349
1350
        auto name_it = std::find_if(vec_names.begin(), vec_names.end(), [&](auto& name) {
            return (map_actv_funcs.count(name) == 0);
        });
Shucai Xiao's avatar
Shucai Xiao committed
1351
        if(name_it != vec_names.end())
1352
1353
1354
        {
            MIGRAPHX_THROW("LSTM: activation function " + std::string(*name_it) + " not supported");
        }
Shucai Xiao's avatar
Shucai Xiao committed
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376

        std::vector<operation> vec_actv_funcs(vec_names.size());
        std::transform(vec_names.begin(), vec_names.end(), vec_actv_funcs.begin(), [&](auto& name) {
            return map_actv_funcs[name];
        });

        float clip = 0.0;
        if(contains(attributes, "clip"))
        {
            clip = parse_value(attributes.at("clip")).at<float>();
        }

        int input_forget = 0;
        if(contains(attributes, "input_forget"))
        {
            input_forget = parse_value(attributes.at("input_forget")).at<int>();
        }

        // append undefined opeator to make 6 arguments
        if(args.size() < 8)
        {
            auto ins = prog.add_instruction(op::undefined{});
Shucai Xiao's avatar
Shucai Xiao committed
1377
            args.insert(args.end(), 8 - args.size(), ins);
Shucai Xiao's avatar
Shucai Xiao committed
1378
1379
1380
1381
        }

        // first output for concatenation of hidden states
        auto hidden_states = prog.add_instruction(
Shucai Xiao's avatar
Shucai Xiao committed
1382
            op::lstm{hidden_size, vec_actv_funcs, dirct, clip, input_forget}, std::move(args));
Shucai Xiao's avatar
Shucai Xiao committed
1383
1384

        // second output for last lstm output
Shucai Xiao's avatar
Shucai Xiao committed
1385
        auto last_output = prog.add_instruction(op::rnn_last_output{}, hidden_states);
Shucai Xiao's avatar
Shucai Xiao committed
1386
1387
1388
1389
1390
1391

        // third output for last cell output
        auto last_cell_output = prog.add_instruction(op::lstm_last_cell_output{}, hidden_states);

        return {hidden_states, last_output, last_cell_output};
    }
1392

Shucai Xiao's avatar
Shucai Xiao committed
1393
    template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
1394
    instruction_ref parse_reduce_oper(const std::string&,
Shucai Xiao's avatar
Shucai Xiao committed
1395
1396
                                      attribute_map attributes,
                                      std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
1397
1398
1399
1400
    {
        std::size_t n_dim = args.front()->get_shape().lens().size();

        // default to reduce over all dimensions
1401
        std::vector<int64_t> axes(n_dim);
Shucai Xiao's avatar
Shucai Xiao committed
1402
1403
1404
1405
1406
        std::iota(axes.begin(), axes.end(), 0);
        if(contains(attributes, "axes"))
        {
            axes.clear();
            auto&& attr_axes = attributes["axes"].ints();
1407
            axes             = std::vector<int64_t>(attr_axes.begin(), attr_axes.end());
Shucai Xiao's avatar
Shucai Xiao committed
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
        }

        int keep_dims = 1;
        if(contains(attributes, "keepdims"))
        {
            keep_dims = parse_value(attributes.at("keepdims")).at<int>();
        }

        if(keep_dims == 1)
        {
Shucai Xiao's avatar
Shucai Xiao committed
1418
            return prog.add_instruction(T{axes}, std::move(args));
Shucai Xiao's avatar
Shucai Xiao committed
1419
1420
1421
        }
        else
        {
Shucai Xiao's avatar
Shucai Xiao committed
1422
            auto ins = prog.add_instruction(T{axes}, std::move(args));
1423
            return prog.add_instruction(op::squeeze{axes}, ins);
1424
1425
        }
    }
1426

Shucai Xiao's avatar
Shucai Xiao committed
1427
1428
    instruction_ref
    parse_cast(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
1429
    {
Shucai Xiao's avatar
Shucai Xiao committed
1430
        if(!contains(attributes, "to"))
1431
1432
1433
1434
        {
            MIGRAPHX_THROW("PARSE_CAST: missing to type attribute!");
        }

Shucai Xiao's avatar
Shucai Xiao committed
1435
        int to_type        = parse_value(attributes.at("to")).at<int>();
1436
1437
1438
        shape::type_t type = get_type(to_type);
        return prog.add_instruction(op::convert{type}, std::move(args));
    }
Shucai Xiao's avatar
Shucai Xiao committed
1439

Paul's avatar
Paul committed
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
    void parse_from(std::istream& is)
    {
        onnx::ModelProto model;
        if(model.ParseFromIstream(&is))
        {
            if(model.has_graph())
            {
                this->parse_graph(model.graph());
            }
        }
        else
        {
Paul's avatar
Paul committed
1452
            MIGRAPHX_THROW("Failed reading onnx file.");
Paul's avatar
Paul committed
1453
1454
1455
1456
1457
1458
        }
    }

    void parse_graph(const onnx::GraphProto& graph)
    {
        nodes = get_nodes(graph);
1459
1460
1461
1462
1463
        std::unordered_map<std::string, onnx::TensorProto> initializer_data;
        for(auto&& f : graph.initializer())
        {
            initializer_data[f.name()] = f;
        }
Paul's avatar
Paul committed
1464
1465
1466
        for(auto&& input : graph.input())
        {
            const std::string& name = input.name();
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
            // Does the input have an initializer?
            if(contains(initializer_data, name))
            {
                auto t             = initializer_data[name];
                instructions[name] = prog.add_literal(parse_tensor(t));
            }
            else
            {
                // TODO: Get shape of input parameter
                shape s            = parse_type(input.type());
                instructions[name] = prog.add_parameter(name, s);
            }
Paul's avatar
Paul committed
1479
        }
Paul's avatar
Paul committed
1480
        for(auto&& output : graph.output())
Paul's avatar
Paul committed
1481
        {
Paul's avatar
Paul committed
1482
            this->parse_node(output.name());
Paul's avatar
Paul committed
1483
1484
1485
        }
    }

Shucai Xiao's avatar
Shucai Xiao committed
1486
    void parse_undefined(const std::string& name)
1487
    {
Shucai Xiao's avatar
Shucai Xiao committed
1488
        auto ins           = prog.add_instruction(op::undefined{});
1489
1490
1491
        instructions[name] = ins;
    }

Paul's avatar
Paul committed
1492
    void parse_node(const std::string& name)
Paul's avatar
Paul committed
1493
    {
Paul's avatar
Paul committed
1494
        if(name.empty())
Paul's avatar
Paul committed
1495
            MIGRAPHX_THROW("Onnx node must have a name");
Paul's avatar
Paul committed
1496
1497
1498
1499
1500
1501
1502
1503
        if(instructions.count(name) == 0)
        {
            auto&& node = nodes.at(name);
            std::vector<instruction_ref> args;
            for(auto&& input : node.input())
            {
                if(nodes.count(input) > 0)
                {
Paul's avatar
Paul committed
1504
1505
                    assert(name != input);
                    this->parse_node(input);
Paul's avatar
Paul committed
1506
                }
Shucai Xiao's avatar
Shucai Xiao committed
1507
                else if(input.empty())
Paul's avatar
Paul committed
1508
                {
1509
                    this->parse_undefined(input);
Paul's avatar
Paul committed
1510
                }
1511
                args.push_back(instructions.at(input));
Paul's avatar
Paul committed
1512
            }
Paul's avatar
Paul committed
1513
            std::vector<instruction_ref> result;
Paul's avatar
Paul committed
1514
1515
            if(ops.count(node.op_type()) == 0)
            {
1516
                result.push_back(prog.add_instruction(op::unknown{node.op_type()}, args));
Paul's avatar
Paul committed
1517
1518
1519
            }
            else
            {
Paul's avatar
Paul committed
1520
                result = ops[node.op_type()](get_attributes(node), args);
Paul's avatar
Paul committed
1521
            }
Paul's avatar
Paul committed
1522
            // Even no output nodes produce output in migraphx
Paul's avatar
Paul committed
1523
            if(node.output().empty() and result.size() == 1)
Paul's avatar
Paul committed
1524
1525
            {
                instructions[name] = result.front();
Paul's avatar
Paul committed
1526
1527
1528
            }
            else
            {
Paul's avatar
Paul committed
1529
1530
1531
1532
1533
1534
                assert(node.output().size() >= result.size());
                std::transform(result.begin(),
                               result.end(),
                               node.output().begin(),
                               std::inserter(instructions, instructions.end()),
                               [](auto&& x, auto&& y) { return std::make_pair(y, x); });
Paul's avatar
Paul committed
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
            }
        }
    }

    static attribute_map get_attributes(const onnx::NodeProto& node)
    {
        std::unordered_map<std::string, onnx::AttributeProto> result;
        for(auto&& attr : node.attribute())
        {
            result[attr.name()] = attr;
        }
        return result;
    }

    static node_map get_nodes(const onnx::GraphProto& graph)
    {
        std::unordered_map<std::string, onnx::NodeProto> result;
Paul's avatar
Paul committed
1552
        std::size_t n = 0;
Paul's avatar
Paul committed
1553
1554
        for(auto&& node : graph.node())
        {
Paul's avatar
Paul committed
1555
            if(node.output().empty())
Paul's avatar
Paul committed
1556
            {
Paul's avatar
Paul committed
1557
                if(node.name().empty())
Paul's avatar
Paul committed
1558
1559
1560
1561
1562
1563
1564
1565
1566
                {
                    result["migraphx_unamed_node_" + std::to_string(n)] = node;
                    n++;
                }
                else
                {
                    result[node.name()] = node;
                }
            }
Paul's avatar
Paul committed
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
            for(auto&& output : node.output())
            {
                result[output] = node;
            }
        }
        return result;
    }

    template <class T>
    static literal from_repeated(shape::type_t t, const T& r)
    {
        std::size_t size = r.size();
        return literal{{t, {size}}, r.begin(), r.end()};
    }

    static literal parse_value(const onnx::AttributeProto& attr)
    {
        switch(attr.type())
        {
        case onnx::AttributeProto::UNDEFINED: return {};
        case onnx::AttributeProto::FLOAT: return literal{attr.f()};
        case onnx::AttributeProto::INT: return literal{attr.i()};
        case onnx::AttributeProto::STRING: return {};
        case onnx::AttributeProto::TENSOR: return parse_tensor(attr.t());
        case onnx::AttributeProto::GRAPH: return {};
Paul's avatar
Paul committed
1592
        case onnx::AttributeProto::FLOATS: return from_repeated(shape::float_type, attr.floats());
Paul's avatar
Paul committed
1593
1594
1595
1596
1597
        case onnx::AttributeProto::INTS: return from_repeated(shape::int64_type, attr.ints());
        case onnx::AttributeProto::STRINGS: return {};
        case onnx::AttributeProto::TENSORS: return {};
        case onnx::AttributeProto::GRAPHS: return {};
        }
Paul's avatar
Paul committed
1598
        MIGRAPHX_THROW("Invalid attribute type");
Paul's avatar
Paul committed
1599
1600
1601
1602
1603
    }

    static literal parse_tensor(const onnx::TensorProto& t)
    {
        std::vector<std::size_t> dims(t.dims().begin(), t.dims().end());
1604
1605
        if(t.has_raw_data())
        {
wsttiger's avatar
wsttiger committed
1606
            const std::string& s = t.raw_data();
Scott Thornton's avatar
Scott Thornton committed
1607
1608
1609
            switch(t.data_type())
            {
            case onnx::TensorProto::UNDEFINED: throw std::runtime_error("");
1610
            case onnx::TensorProto::FLOAT: return create_literal(shape::float_type, dims, s.data());
Scott Thornton's avatar
Scott Thornton committed
1611
            case onnx::TensorProto::UINT8: throw std::runtime_error("");
1612
            case onnx::TensorProto::INT8: return create_literal(shape::int32_type, dims, s.data());
Khalique's avatar
Khalique committed
1613
1614
            case onnx::TensorProto::UINT16:
                return create_literal(shape::int32_type, dims, s.data());
1615
1616
1617
            case onnx::TensorProto::INT16: return create_literal(shape::int32_type, dims, s.data());
            case onnx::TensorProto::INT32: return create_literal(shape::int32_type, dims, s.data());
            case onnx::TensorProto::INT64: return create_literal(shape::int64_type, dims, s.data());
Scott Thornton's avatar
Scott Thornton committed
1618
            case onnx::TensorProto::STRING: throw std::runtime_error("");
1619
            case onnx::TensorProto::BOOL: return create_literal(shape::int32_type, dims, s.data());
Khalique's avatar
Khalique committed
1620
1621
1622
1623
            case onnx::TensorProto::FLOAT16:
                return create_literal(shape::half_type, dims, s.data());
            case onnx::TensorProto::DOUBLE:
                return create_literal(shape::double_type, dims, s.data());
Scott Thornton's avatar
Scott Thornton committed
1624
1625
1626
1627
1628
            case onnx::TensorProto::UINT32: throw std::runtime_error("");
            case onnx::TensorProto::UINT64: throw std::runtime_error("");
            case onnx::TensorProto::COMPLEX64: throw std::runtime_error("");
            case onnx::TensorProto::COMPLEX128: throw std::runtime_error("");
            }
Paul's avatar
Paul committed
1629
            MIGRAPHX_THROW("Invalid tensor type");
1630
        }
Paul's avatar
Paul committed
1631
1632
1633
1634
        switch(t.data_type())
        {
        case onnx::TensorProto::UNDEFINED: throw std::runtime_error("");
        case onnx::TensorProto::FLOAT:
Khalique's avatar
Khalique committed
1635
            return create_literal(shape::float_type, dims, t.float_data());
Paul's avatar
Paul committed
1636
1637
        case onnx::TensorProto::UINT8: throw std::runtime_error("");
        case onnx::TensorProto::INT8:
Khalique's avatar
Khalique committed
1638
            return create_literal(shape::int32_type, dims, t.int32_data());
Paul's avatar
Paul committed
1639
        case onnx::TensorProto::UINT16:
Khalique's avatar
Khalique committed
1640
            return create_literal(shape::int32_type, dims, t.int32_data());
Paul's avatar
Paul committed
1641
        case onnx::TensorProto::INT16:
Khalique's avatar
Khalique committed
1642
            return create_literal(shape::int32_type, dims, t.int32_data());
Paul's avatar
Paul committed
1643
        case onnx::TensorProto::INT32:
Khalique's avatar
Khalique committed
1644
            return create_literal(shape::int32_type, dims, t.int32_data());
Paul's avatar
Paul committed
1645
        case onnx::TensorProto::INT64:
Khalique's avatar
Khalique committed
1646
            return create_literal(shape::int64_type, dims, t.int64_data());
Paul's avatar
Paul committed
1647
1648
        case onnx::TensorProto::STRING: throw std::runtime_error("");
        case onnx::TensorProto::BOOL:
Khalique's avatar
Khalique committed
1649
            return create_literal(shape::int32_type, dims, t.int32_data());
Paul's avatar
Paul committed
1650
        case onnx::TensorProto::FLOAT16:
Khalique's avatar
Khalique committed
1651
        {
Khalique's avatar
Khalique committed
1652
            std::vector<uint16_t> data_uint16(t.int32_data().begin(), t.int32_data().end());
1653
            std::vector<half> data_half;
Khalique's avatar
Khalique committed
1654
1655
1656
            std::transform(data_uint16.begin(),
                           data_uint16.end(),
                           std::back_inserter(data_half),
1657
                           [](uint16_t raw_val) { return *reinterpret_cast<half*>(&raw_val); });
1658
            return create_literal(shape::half_type, dims, data_half);
Khalique's avatar
Khalique committed
1659
        }
Paul's avatar
Paul committed
1660
        case onnx::TensorProto::DOUBLE:
Khalique's avatar
Khalique committed
1661
            return create_literal(shape::double_type, dims, t.double_data());
Paul's avatar
Paul committed
1662
1663
1664
1665
1666
        case onnx::TensorProto::UINT32: throw std::runtime_error("");
        case onnx::TensorProto::UINT64: throw std::runtime_error("");
        case onnx::TensorProto::COMPLEX64: throw std::runtime_error("");
        case onnx::TensorProto::COMPLEX128: throw std::runtime_error("");
        }
Paul's avatar
Paul committed
1667
        MIGRAPHX_THROW("Invalid tensor type");
Paul's avatar
Paul committed
1668
1669
    }

Khalique's avatar
Khalique committed
1670
    static literal
1671
    create_literal(shape::type_t shape_type, const std::vector<size_t>& dims, const char* data)
1672
    {
Khalique's avatar
Khalique committed
1673
        // in case of scalar constants in onnx file, use dims=1 to fill initializer data
1674
        if(dims.empty())
1675
            return literal{{shape_type}, data};
1676
1677
1678
        return literal{{shape_type, dims}, data};
    }

1679
    template <class T, MIGRAPHX_REQUIRES(not std::is_pointer<T>{})>
Khalique's avatar
Khalique committed
1680
    static literal create_literal(shape::type_t shape_type, const std::vector<size_t>& dims, T data)
1681
1682
    {
        if(dims.empty())
1683
            return literal{{shape_type}, data.begin(), data.end()};
1684
        return literal{{shape_type, dims}, data.begin(), data.end()};
1685
1686
    }

Paul's avatar
Paul committed
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
    static shape parse_type(const onnx::TypeProto& t)
    {
        shape::type_t shape_type{};
        switch(t.tensor_type().elem_type())
        {
        case onnx::TensorProto::UNDEFINED:
            break; // throw std::runtime_error("Unsupported type UNDEFINED");
        case onnx::TensorProto::FLOAT: shape_type = shape::float_type; break;
        case onnx::TensorProto::UINT8:
            break; // throw std::runtime_error("Unsupported type UINT8");
        case onnx::TensorProto::INT8: shape_type = shape::int8_type; break;
        case onnx::TensorProto::UINT16: shape_type = shape::uint16_type; break;
        case onnx::TensorProto::INT16: shape_type = shape::int16_type; break;
        case onnx::TensorProto::INT32: shape_type = shape::int32_type; break;
        case onnx::TensorProto::INT64: shape_type = shape::int64_type; break;
        case onnx::TensorProto::STRING:
            break; // throw std::runtime_error("Unsupported type STRING");
        case onnx::TensorProto::BOOL:
            break; // throw std::runtime_error("Unsupported type BOOL");
Paul's avatar
Paul committed
1706
        case onnx::TensorProto::FLOAT16: shape_type = shape::half_type; break;
Paul's avatar
Paul committed
1707
1708
1709
1710
1711
1712
1713
1714
1715
        case onnx::TensorProto::DOUBLE: shape_type = shape::double_type; break;
        case onnx::TensorProto::UINT32: shape_type = shape::uint32_type; break;
        case onnx::TensorProto::UINT64: shape_type = shape::uint64_type; break;
        case onnx::TensorProto::COMPLEX64:
            break; // throw std::runtime_error("Unsupported type COMPLEX64");
        case onnx::TensorProto::COMPLEX128:
            break; // throw std::runtime_error("Unsupported type COMPLEX128");
        }
        std::vector<std::size_t> dims;
Paul's avatar
Paul committed
1716
        auto&& tensor_dims = t.tensor_type().shape().dim();
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
        std::transform(tensor_dims.begin(),
                       tensor_dims.end(),
                       std::back_inserter(dims),
                       [](auto&& d) -> std::size_t {
                           if(not d.has_dim_value())
                           {
                               long default_batch_size = 1; // FIXME
                               return default_batch_size;
                           }
                           return d.dim_value();
                       });
Paul's avatar
Paul committed
1728
1729
        return {shape_type, dims};
    }
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751

    shape::type_t get_type(int dtype)
    {
        switch(dtype)
        {
        case 1: return shape::float_type;
        case 2: return shape::uint8_type;
        case 3: return shape::int8_type;
        case 4: return shape::uint16_type;
        case 5: return shape::int16_type;
        case 6: return shape::int32_type;
        case 7: return shape::int64_type;
        case 10: return shape::half_type;
        case 11: return shape::double_type;
        case 12: return shape::uint32_type;
        case 13: return shape::uint64_type;
        default:
        {
            MIGRAPHX_THROW("Prototensor data type " + std::to_string(dtype) + " not supported");
        }
        }
    }
Paul's avatar
Paul committed
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
};

program parse_onnx(const std::string& name)
{
    std::fstream input(name.c_str(), std::ios::in | std::ios::binary);
    onnx_parser parser;
#ifndef NDEBUG
    // Log the program when it can't be parsed
    try
    {
        parser.parse_from(input);
    }
    catch(...)
    {
        std::cerr << parser.prog << std::endl;
        throw;
    }
#else
    parser.parse_from(input);
#endif
    return std::move(parser.prog);
}

Paul's avatar
Paul committed
1775
} // namespace MIGRAPHX_INLINE_NS
Paul's avatar
Paul committed
1776
} // namespace migraphx