onnx.cpp 66.6 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);
217
218
219
220
221
222
223
224
225
226
227
            if(!arg0->get_shape().standard())
            {
                arg0 = prog.add_instruction(op::contiguous{}, arg0);
            }
            if(!arg1->get_shape().standard())
            {
                arg1 = prog.add_instruction(op::contiguous{}, arg1);
            }

            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
228
229
230
231
232
233
            return prog.add_instruction(x, l0, l1);
        }
        else
        {
            return prog.add_instruction(x, {arg0, arg1});
        }
234
235
    }

Paul's avatar
Paul committed
236
    template <class T>
Paul's avatar
Paul committed
237
238
    void add_generic_op(std::string name, T x)
    {
Paul's avatar
Paul committed
239
        add_op(name, [this, x](const attribute_map&, std::vector<instruction_ref> args) {
Paul's avatar
Paul committed
240
241
242
243
            return prog.add_instruction(x, args);
        });
    }

Khalique's avatar
Khalique committed
244
    template <class T>
Khalique's avatar
Khalique committed
245
    void add_variadic_op(std::string name, T x)
Khalique's avatar
Khalique committed
246
    {
Paul's avatar
Paul committed
247
        add_op(name, [this, x](const attribute_map&, std::vector<instruction_ref> args) {
Khalique's avatar
Khalique committed
248
            return std::accumulate(std::next(args.begin()),
Khalique's avatar
Khalique committed
249
250
251
252
253
                                   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
254
        });
Khalique's avatar
Khalique committed
255
256
    }

Khalique's avatar
Khalique committed
257
258
259
    instruction_ref parse_clip(const std::string&,
                               const attribute_map& attributes,
                               std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
260
261
262
263
264
265
266
267
268
269
270
271
272
    {
        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));
    }

Shucai Xiao's avatar
Shucai Xiao committed
273
274
275
276
277
278
279
280
281
282
    //    instruction_ref
    //    parse_softmax(const std::string&, const attribute_map&, std::vector<instruction_ref> args)
    //    {
    //        auto dims = args.front()->get_shape().lens();
    //        auto r =
    //            prog.add_instruction(op::reshape{{long(dims[0]), long(dims[1]), 1, 1}},
    //            args.front());
    //        auto s = prog.add_instruction(op::softmax{}, r);
    //        return prog.add_instruction(op::reshape{{long(dims[0]), long(dims[1])}}, s);
    //    }
283
284

    instruction_ref parse_softmax(const std::string&,
Shucai Xiao's avatar
Shucai Xiao committed
285
286
                                  const attribute_map& attributes,
                                  std::vector<instruction_ref> args)
Paul's avatar
Paul committed
287
    {
288
289
290
291
292
293
294
        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
295
296
    }

Shucai Xiao's avatar
Shucai Xiao committed
297
298
299
    instruction_ref parse_logsoftmax(const std::string&,
                                     const attribute_map& attributes,
                                     std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
300
301
302
303
304
305
306
307
308
309
    {
        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));
    }

310
    instruction_ref parse_argmax(const std::string&,
Shucai Xiao's avatar
Shucai Xiao committed
311
312
                                 const attribute_map& attributes,
                                 std::vector<instruction_ref> args)
313
    {
314
        int64_t axis = 0;
315
316
        if(contains(attributes, "axis"))
        {
317
            axis = static_cast<int64_t>(parse_value(attributes.at("axis")).at<int>());
318
319
        }

Shucai Xiao's avatar
Shucai Xiao committed
320
        int keep_dims = 1;
Shucai Xiao's avatar
Shucai Xiao committed
321
        if(contains(attributes, "keepdims"))
Shucai Xiao's avatar
Shucai Xiao committed
322
323
324
325
        {
            keep_dims = parse_value(attributes.at("keepdims")).at<int>();
        }

Shucai Xiao's avatar
Shucai Xiao committed
326
        if(keep_dims == 0)
327
328
        {
            auto ins = prog.add_instruction(op::argmax{axis}, std::move(args));
329
            return prog.add_instruction(op::squeeze{{axis}}, ins);
330
331
332
333
334
        }
        else
        {
            return prog.add_instruction(op::argmax{axis}, std::move(args));
        }
335
336
337
    }

    instruction_ref parse_argmin(const std::string&,
Shucai Xiao's avatar
Shucai Xiao committed
338
339
                                 const attribute_map& attributes,
                                 std::vector<instruction_ref> args)
340
    {
341
        int64_t axis = 0;
342
343
        if(contains(attributes, "axis"))
        {
344
            axis = static_cast<int64_t>(parse_value(attributes.at("axis")).at<int>());
345
346
        }

Shucai Xiao's avatar
Shucai Xiao committed
347
        int keep_dims = 1;
Shucai Xiao's avatar
Shucai Xiao committed
348
        if(contains(attributes, "keepdims"))
Shucai Xiao's avatar
Shucai Xiao committed
349
350
351
352
        {
            keep_dims = parse_value(attributes.at("keepdims")).at<int>();
        }

Shucai Xiao's avatar
Shucai Xiao committed
353
        if(keep_dims == 0)
354
355
        {
            auto ins = prog.add_instruction(op::argmin{axis}, std::move(args));
356
            return prog.add_instruction(op::squeeze{{axis}}, ins);
357
358
359
360
361
        }
        else
        {
            return prog.add_instruction(op::argmin{axis}, std::move(args));
        }
362
363
    }

Paul's avatar
Paul committed
364
    instruction_ref
Paul's avatar
Paul committed
365
    parse_conv(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
366
    {
367
        op::convolution op;
368
        auto l0 = args[0];
Paul's avatar
Paul committed
369
370
        if(contains(attributes, "pads"))
        {
Scott Thornton's avatar
Scott Thornton committed
371
            if(contains(attributes, "auto_pad"))
372
            {
Paul's avatar
Paul committed
373
                MIGRAPHX_THROW("auto_pad and padding cannot be specified simultaneously");
374
            }
375
376
            std::vector<std::int64_t> padding;
            copy(attributes["pads"].ints(), std::back_inserter(padding));
Scott Thornton's avatar
Scott Thornton committed
377
            if(padding.size() != 4)
378
            {
Paul's avatar
Paul committed
379
                MIGRAPHX_THROW("padding should have 4 values");
380
            }
Scott Thornton's avatar
Scott Thornton committed
381
            if(padding[0] != padding[2] || padding[1] != padding[3])
382
            {
383
384
                // 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
385
                l0      = prog.add_instruction(op::pad{padding}, l0);
386
            }
387
388
389
390
            else
            {
                op.padding[0] = padding[0];
                op.padding[1] = padding[1];
391
            }
Paul's avatar
Paul committed
392
        }
Paul's avatar
Paul committed
393
394
395
396
397
398
399
400
        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
401
        if(contains(attributes, "auto_pad"))
402
403
        {
            auto s = attributes["auto_pad"].s();
Scott Thornton's avatar
Scott Thornton committed
404
            if(contains(attributes, "pads") and to_upper(s) != "NOTSET")
405
            {
Paul's avatar
Paul committed
406
                MIGRAPHX_THROW("auto_pad and padding cannot be specified simultaneously");
407
408
            }

wsttiger's avatar
fixes  
wsttiger committed
409
            if(s.find("SAME") != std::string::npos)
410
            {
411
                op.padding_mode = op::padding_mode_t::same;
412
413
            }
        }
Khalique's avatar
Khalique committed
414
415
416
417
        if(contains(attributes, "group"))
        {
            op.group = parse_value(attributes.at("group")).at<int>();
        }
Paul's avatar
Paul committed
418
419
420
421
        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
422
            auto l2 = prog.add_instruction(op::broadcast{axis, l1->get_shape().lens()}, args[2]);
423
            return prog.add_instruction(op::add{}, l1, l2);
Paul's avatar
Paul committed
424
        }
425
        return prog.add_instruction(op, l0, args[1]);
Paul's avatar
Paul committed
426
    }
Paul's avatar
Paul committed
427

Paul's avatar
Paul committed
428
429
430
    instruction_ref parse_pooling(const std::string& name,
                                  attribute_map attributes,
                                  std::vector<instruction_ref> args)
Paul's avatar
Paul committed
431
    {
Khalique's avatar
Khalique committed
432
        op::pooling op{ends_with(name, "MaxPool") ? "max" : "average"};
433
        auto l0 = args[0];
Khalique's avatar
Khalique committed
434
        if(starts_with(name, "Global"))
435
        {
Khalique's avatar
Khalique committed
436
437
            auto lens  = args.front()->get_shape().lens();
            op.lengths = {lens[2], lens[3]};
438
        }
Paul's avatar
Paul committed
439
440
        if(contains(attributes, "pads"))
        {
441
442
            std::vector<std::int64_t> padding;
            copy(attributes["pads"].ints(), std::back_inserter(padding));
Scott Thornton's avatar
Scott Thornton committed
443
            if(padding.size() != 4)
444
            {
Paul's avatar
Paul committed
445
                MIGRAPHX_THROW("padding should have 4 values");
446
            }
Scott Thornton's avatar
Scott Thornton committed
447
            if(padding[0] != padding[2] || padding[1] != padding[3])
448
            {
449
450
                // 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
451
452
                l0 = prog.add_instruction(op::pad{padding, std::numeric_limits<float>::lowest()},
                                          l0);
453
454
455
456
457
            }
            else
            {
                op.padding[0] = padding[0];
                op.padding[1] = padding[1];
458
            }
Paul's avatar
Paul committed
459
460
461
462
463
464
465
466
467
        }
        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
468
        if(contains(attributes, "auto_pad"))
469
470
        {
            auto s = attributes["auto_pad"].s();
471
            if(s.find("SAME_UPPER") == std::string::npos)
472
            {
473
                MIGRAPHX_THROW("auto_pad only supports SAME_UPPER for pooling");
474
            }
475
            op.padding_mode = op::padding_mode_t::same;
476
477
        }

478
        return prog.add_instruction(op, l0);
Paul's avatar
Paul committed
479
480
    }

Paul's avatar
Paul committed
481
    instruction_ref
Paul's avatar
Paul committed
482
    parse_reshape(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
483
    {
484
        op::reshape op;
Paul's avatar
Paul committed
485
486
        if(args.size() == 1)
        {
Shucai Xiao's avatar
Shucai Xiao committed
487
            if(contains(attributes, "shape"))
488
489
490
491
492
493
            {
                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
494
495
496
                MIGRAPHX_THROW(
                    "Parse_reshape: shape attribute is needed when only one argument is provided!");
            }
Paul's avatar
Paul committed
497
498
499
        }
        if(args.size() == 2)
        {
Paul's avatar
Paul committed
500
            auto s = args[1]->eval();
Paul's avatar
Paul committed
501
            if(s.empty())
Paul's avatar
Paul committed
502
                MIGRAPHX_THROW("Dynamic shape is not supported.");
Paul's avatar
Paul committed
503
            s.visit([&](auto v) { copy(v, std::back_inserter(op.dims)); });
Paul's avatar
Paul committed
504
        }
505

Shucai Xiao's avatar
Shucai Xiao committed
506
        if(!args[0]->get_shape().standard())
507
508
509
510
        {
            args[0] = prog.add_instruction(op::contiguous{}, args[0]);
        }

Paul's avatar
Paul committed
511
512
513
        return prog.add_instruction(op, args[0]);
    }

Paul's avatar
Paul committed
514
    instruction_ref
Paul's avatar
Paul committed
515
    parse_flatten(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
516
    {
517
        uint64_t axis = 1;
Paul's avatar
Paul committed
518
519
520
521
        if(contains(attributes, "axis"))
        {
            axis = parse_value(attributes.at("axis")).at<int>();
        }
522
        return prog.add_instruction(op::flatten{axis}, args[0]);
Paul's avatar
Paul committed
523
524
    }

525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
    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
543
544
545
546
547
548
549
    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));
    }
550

551
552
553
    instruction_ref
    parse_gather(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
554
        int axis = 0;
555
556
557
558
        if(contains(attributes, "axis"))
        {
            axis = parse_value(attributes.at("axis")).at<int>();
        }
559
        op::gather op{axis};
560
561
562
        return prog.add_instruction(op, std::move(args));
    }

563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
    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
583
584
585
    instruction_ref parse_constant(const std::string&,
                                   attribute_map attributes,
                                   const std::vector<instruction_ref>&)
Paul's avatar
Paul committed
586
    {
Shucai Xiao's avatar
Shucai Xiao committed
587
        literal v = parse_value(attributes.at("value"));
588
        // return empty literal
Shucai Xiao's avatar
Shucai Xiao committed
589
        if(v.get_shape().elements() == 0)
590
591
592
593
        {
            return prog.add_literal(literal{});
        }

594
595
596
        auto dim_size = attributes.at("value").t().dims_size();
        // if dim_size is 0, it is a scalar
        if(dim_size == 0)
597
        {
598
            migraphx::shape scalar_shape{v.get_shape().type()};
599
600
601
            return prog.add_literal(migraphx::literal{scalar_shape, v.data()});
        }

Paul's avatar
Paul committed
602
603
        return prog.add_literal(v);
    }
Paul's avatar
Paul committed
604

Paul's avatar
Paul committed
605
    instruction_ref
Paul's avatar
Paul committed
606
    parse_gemm(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
607
608
    {
        float alpha = 1.0f;
Khalique's avatar
Khalique committed
609
        float beta  = 1.0f;
Paul's avatar
Paul committed
610
611
612
613
614
615
616
617
        bool transa = false;
        bool transb = false;
        if(contains(attributes, "alpha"))
        {
            alpha = parse_value(attributes.at("alpha")).at<float>();
        }
        if(contains(attributes, "beta"))
        {
618
            beta = parse_value(attributes.at("beta")).at<float>();
Paul's avatar
Paul committed
619
620
621
622
623
624
625
626
627
        }
        if(contains(attributes, "transA"))
        {
            transa = parse_value(attributes.at("transA")).at<bool>();
        }
        if(contains(attributes, "transB"))
        {
            transb = parse_value(attributes.at("transB")).at<bool>();
        }
628
629
630
631
632
633

        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));

634
635
        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
636
637
        if(args.size() == 3)
        {
638
            if(beta != 0.f && args[2]->get_shape().elements() > 0)
639
            {
Shucai Xiao's avatar
Shucai Xiao committed
640
                auto out_lens   = l1->get_shape().lens();
641
                out_lens.back() = l2->get_shape().lens().back();
Shucai Xiao's avatar
Shucai Xiao committed
642
                auto l3         = args[2];
Shucai Xiao's avatar
Shucai Xiao committed
643
644
                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
645
                {
646
647
648
649
                    if(!args[2]->get_shape().standard())
                    {
                        args[2] = prog.add_instruction(op::contiguous{}, args[2]);
                    }
650
                    l3 = prog.add_instruction(op::multibroadcast{out_lens}, args[2]);
Khalique's avatar
Khalique committed
651
                }
652
                return prog.add_instruction(op::dot{alpha, beta}, l1, l2, l3);
653
            }
Paul's avatar
Paul committed
654
        }
655
656

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

659
    instruction_ref
Shucai Xiao's avatar
Shucai Xiao committed
660
    parse_matmul(const std::string&, const attribute_map&, std::vector<instruction_ref> args)
661
    {
Shucai Xiao's avatar
Shucai Xiao committed
662
663
        auto l0      = args[0];
        auto l1      = args[1];
664
665
666
667
668
        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
669
        if(l0_lens.size() == 1)
670
671
672
673
674
675
676
        {
            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
677
        if(l1_lens.size() == 1)
678
679
680
681
682
683
684
685
        {
            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
686
        if(!std::equal(l0_lens.rbegin() + 2, l0_lens.rend(), l1_lens.rbegin() + 2, l1_lens.rend()))
687
688
689
690
691
692
        {
            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);
693
            l0_broadcasted_lens = output_lens;
694
            l0_broadcasted_lens.insert(l0_broadcasted_lens.end(), l0_it, l0_lens.end());
695
            l1_broadcasted_lens = output_lens;
696
            l1_broadcasted_lens.insert(l1_broadcasted_lens.end(), l1_it, l1_lens.end());
Shucai Xiao's avatar
Shucai Xiao committed
697
            if(l0_lens != l0_broadcasted_lens)
698
            {
699
700
701
702
                if(!l0->get_shape().standard())
                {
                    l0 = prog.add_instruction(op::contiguous{}, l0);
                }
703
704
                bl0 = prog.add_instruction(op::multibroadcast{l0_broadcasted_lens}, l0);
            }
Shucai Xiao's avatar
Shucai Xiao committed
705
            if(l1_lens != l1_broadcasted_lens)
706
            {
707
708
709
710
                if(!l1->get_shape().standard())
                {
                    l1 = prog.add_instruction(op::contiguous{}, l1);
                }
711
712
713
714
                bl1 = prog.add_instruction(op::multibroadcast{l1_broadcasted_lens}, l1);
            }
        }

715
716
717
718
719
720
721
722
        if(!bl1->get_shape().standard())
        {
            bl1 = prog.add_instruction(op::contiguous{}, bl1);
        }
        if(!bl0->get_shape().standard())
        {
            bl0 = prog.add_instruction(op::contiguous{}, bl0);
        }
Shucai Xiao's avatar
Shucai Xiao committed
723
        auto dot_res     = prog.add_instruction(op::dot{1.0f, 0.0f}, bl0, bl1);
724
        int64_t num_axis = static_cast<int64_t>(dot_res->get_shape().lens().size());
Shucai Xiao's avatar
Shucai Xiao committed
725
        if(is_a_prepended)
726
727
728
729
        {
            dot_res = prog.add_instruction(op::squeeze{{num_axis - 2}}, dot_res);
            --num_axis;
        }
Shucai Xiao's avatar
Shucai Xiao committed
730
        if(is_b_appended)
731
732
733
        {
            dot_res = prog.add_instruction(op::squeeze{{num_axis - 1}}, dot_res);
        }
Shucai Xiao's avatar
Shucai Xiao committed
734

735
736
737
        return dot_res;
    }

738
    instruction_ref
Paul's avatar
Paul committed
739
    parse_batchnorm(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
740
    {
Scott Thornton's avatar
Scott Thornton committed
741
742
        float epsilon                                     = 1e-5f;
        float momentum                                    = 0.9f;
743
        op::batch_norm_inference::bn_infer_mode_t bn_mode = op::batch_norm_inference::spatial;
Scott Thornton's avatar
Scott Thornton committed
744
        bool is_test                                      = false;
745
746
747
748
749
750
        if(contains(attributes, "epsilon"))
        {
            epsilon = parse_value(attributes.at("epsilon")).at<float>();
        }
        if(contains(attributes, "momentum"))
        {
751
            momentum = parse_value(attributes.at("momentum")).at<float>();
752
753
754
        }
        if(contains(attributes, "is_test"))
        {
wsttiger's avatar
wsttiger committed
755
            is_test = parse_value(attributes.at("is_test")).at<uint64_t>() > 0;
756
757
758
        }
        if(contains(attributes, "spatial"))
        {
759
            bn_mode = (parse_value(attributes.at("spatial")).at<uint64_t>() > 0)
760
761
                          ? op::batch_norm_inference::spatial
                          : op::batch_norm_inference::per_activation;
762
        }
Paul's avatar
Paul committed
763
        (void)is_test;
Paul's avatar
Paul committed
764
        op::batch_norm_inference op{epsilon, momentum, bn_mode};
Paul's avatar
Paul committed
765
        return prog.add_instruction(op, std::move(args));
766
767
    }

768
769
770
771
    instruction_ref parse_leaky_relu(const std::string&,
                                     attribute_map attributes,
                                     std::vector<instruction_ref> args)
    {
Khalique's avatar
Khalique committed
772
        float alpha = 0.01; // default alpha val for leaky relu
773
774
775
776
777
778
779
780
        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
781
782
    instruction_ref
    parse_elu(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
783
784
785
786
787
788
789
790
791
792
    {
        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
793
794
    instruction_ref
    parse_lrn(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
795
796
    {
        float alpha = 0.0001;
Khalique's avatar
Khalique committed
797
798
799
        float beta  = 0.75;
        float bias  = 1.0;
        int size    = 1;
Khalique's avatar
Khalique committed
800
801
802
803
804
805
806
807
808
809
810
811
        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
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
    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());
        }
828
        auto input_lens = args.front()->get_shape().lens();
Khalique's avatar
Khalique committed
829

Khalique's avatar
Khalique committed
830
831
        auto scale_val = prog.add_literal(scale);
        auto bias_vals = prog.add_literal(
Paul's avatar
Paul committed
832
            migraphx::literal{migraphx::shape{migraphx::shape::float_type, {bias.size()}}, bias});
Khalique's avatar
Khalique committed
833

834
        auto scale_tensor = prog.add_instruction(migraphx::op::scalar{input_lens}, scale_val);
Paul's avatar
Paul committed
835
        auto img_scaled   = prog.add_instruction(migraphx::op::mul{}, args.front(), scale_tensor);
Shucai Xiao's avatar
Shucai Xiao committed
836
        auto bias_bcast   = prog.add_instruction(migraphx::op::broadcast{1, input_lens}, bias_vals);
Paul's avatar
Paul committed
837
        return prog.add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);
Khalique's avatar
Khalique committed
838
    }
Khalique's avatar
Khalique committed
839

Khalique's avatar
Khalique committed
840
841
    instruction_ref
    parse_transpose(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
842
843
844
845
846
847
848
    {
        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());
        }
849
850
851
852
        if(!args.front()->get_shape().standard())
        {
            args.front() = prog.add_instruction(migraphx::op::contiguous{}, args.front());
        }
Paul's avatar
Paul committed
853
        return prog.add_instruction(migraphx::op::transpose{perm}, args.front());
Khalique's avatar
Khalique committed
854
855
    }

Khalique's avatar
Khalique committed
856
857
858
859
860
861
862
863
864
865
    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());
        }
866
        // check if padding is actually being done (at least one value is nonzero)
Khalique's avatar
Khalique committed
867
        if(std::all_of(pads.begin(), pads.end(), [](const int& i) { return i == 0; }))
868
869
870
        {
            return prog.add_instruction(migraphx::op::identity{}, args.front());
        }
Khalique's avatar
Khalique committed
871
872
873
874
875
876
877
878
879
880
881
882
        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());
    }
883
884
885
    // 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
886
    parse_shape(const std::string&, const attribute_map&, std::vector<instruction_ref> args)
887
888
    {
        if(args.size() != 1)
889
            MIGRAPHX_THROW("Shape: operator should have 1 operand");
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
        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
926
927
        if(contains(attributes, "extra_shape"))
        {
928
            MIGRAPHX_THROW("ConstantFill: cannot handle extra shape attribute");
929
930
        }

931
932
        if(input_as_shape == 1)
        {
Shucai Xiao's avatar
Shucai Xiao committed
933
            if(args.size() != 1)
934
            {
935
                MIGRAPHX_THROW("ConstantFill: need an input argument as output shape");
936
937
            }

Shucai Xiao's avatar
Shucai Xiao committed
938
939
            if(contains(attributes, "shape"))
            {
940
                MIGRAPHX_THROW("ConstantFill: cannot set the shape argument and pass in an input "
Shucai Xiao's avatar
Shucai Xiao committed
941
                               "at the same time");
942
943
            }

944
945
946
            migraphx::argument in = args[0]->eval();
            if(in.empty())
            {
947
                MIGRAPHX_THROW("ConstantFill: cannot handle dynamic shape as input");
948
            }
949

950
951
952
            std::vector<std::size_t> dims;
            in.visit([&](auto input) { dims.assign(input.begin(), input.end()); });
            migraphx::shape s(type, dims);
953
954
            std::vector<float> values(s.elements(), value);
            return prog.add_literal(migraphx::literal(s, values));
955
956
957
        }
        else if(input_as_shape == 0)
        {
Shucai Xiao's avatar
Shucai Xiao committed
958
959
            if(!contains(attributes, "shape"))
            {
960
                MIGRAPHX_THROW("ConstantFill: attribute output shape is needed");
961
962
963
            }

            literal ls = parse_value(attributes.at("shape"));
964
            std::vector<std::size_t> dims;
Shucai Xiao's avatar
Shucai Xiao committed
965
            ls.visit([&](auto s) { dims.assign(s.begin(), s.end()); });
966
            migraphx::shape s{type, dims};
967
968
            std::vector<float> values(s.elements(), value);
            return prog.add_literal(migraphx::literal(s, values));
969
970
971
        }
        else
        {
972
            MIGRAPHX_THROW("ConstantFill: wrong value of attribute input_as_shape");
973
974
975
        }
    }

Shucai Xiao's avatar
Shucai Xiao committed
976
977
978
    instruction_ref parse_constant_of_shape(const std::string&,
                                            attribute_map attributes,
                                            std::vector<instruction_ref> args)
979
980
    {
        literal l_val{};
Shucai Xiao's avatar
Shucai Xiao committed
981
        if(contains(attributes, "value"))
982
983
        {
            l_val = parse_value(attributes.at("value"));
Shucai Xiao's avatar
Shucai Xiao committed
984
            if(l_val.get_shape().elements() != 1)
985
986
987
988
989
990
991
992
993
994
995
            {
                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();
996

Shucai Xiao's avatar
Shucai Xiao committed
997
        if(args.empty())
998
        {
999
            MIGRAPHX_THROW("Parse ConstantOfShape : must have 1 input!");
1000
1001
1002
        }
        else
        {
1003
1004
            migraphx::shape s;
            // empty input tensor, output is a scalar
Shucai Xiao's avatar
Shucai Xiao committed
1005
            if(args[0]->get_shape().elements() == 0)
1006
            {
1007
                s = migraphx::shape{type, {1}, {0}};
1008
            }
1009
1010
1011
1012
1013
1014
1015
            else
            {
                migraphx::argument in = args[0]->eval();
                if(in.empty())
                {
                    MIGRAPHX_THROW("Parse ConstantOfShape: cannot handle dynamic shape as input");
                }
1016

1017
1018
1019
1020
                std::vector<std::size_t> dims;
                in.visit([&](auto input) { dims.assign(input.begin(), input.end()); });
                s = migraphx::shape{type, dims};
            }
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033

            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
1034
    instruction_ref
Shucai Xiao's avatar
Shucai Xiao committed
1035
    parse_expand(const std::string&, const attribute_map&, std::vector<instruction_ref> args)
1036
    {
Shucai Xiao's avatar
Shucai Xiao committed
1037
        auto in_lens             = args[0]->get_shape().lens();
1038
        migraphx::argument arg_s = args[1]->eval();
Shucai Xiao's avatar
Shucai Xiao committed
1039
        if(arg_s.empty())
1040
1041
1042
1043
1044
1045
        {
            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);
1046

1047
1048
1049
1050
        if(!args[0]->get_shape().standard())
        {
            args[0] = prog.add_instruction(op::contiguous{}, args[0]);
        }
Shucai Xiao's avatar
Shucai Xiao committed
1051
        return prog.add_instruction(op::multibroadcast{out_lens}, args[0]);
1052
1053
    }

Shucai Xiao's avatar
Shucai Xiao committed
1054
    std::vector<instruction_ref>
Shucai Xiao's avatar
Shucai Xiao committed
1055
1056
1057
    parse_rnn(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
    {
        migraphx::shape input_shape = args[0]->get_shape();
1058
        std::size_t hidden_size     = args[1]->get_shape().lens()[1];
Shucai Xiao's avatar
Shucai Xiao committed
1059
1060
1061

        if(contains(attributes, "hidden_size"))
        {
Shucai Xiao's avatar
Shucai Xiao committed
1062
            std::size_t hidden_size_att = parse_value(attributes.at("hidden_size")).at<int>();
Shucai Xiao's avatar
Shucai Xiao committed
1063
            if(hidden_size != hidden_size_att)
Shucai Xiao's avatar
Shucai Xiao committed
1064
1065
1066
            {
                MIGRAPHX_THROW("RNN: hidden size mismatch in input and attribute");
            }
Shucai Xiao's avatar
Shucai Xiao committed
1067
1068
1069
1070
1071
1072
1073
1074
1075
        }

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

1076
        op::rnn_direction dirct = op::rnn_direction::forward;
Shucai Xiao's avatar
Shucai Xiao committed
1077
1078
        if(direction == "bidirectional")
        {
1079
            dirct = op::rnn_direction::bidirectional;
Shucai Xiao's avatar
Shucai Xiao committed
1080
1081
1082
        }
        else if(direction == "reverse")
        {
1083
            dirct = op::rnn_direction::reverse;
Shucai Xiao's avatar
Shucai Xiao committed
1084
1085
        }

1086
        std::vector<std::string> vec_names{"tanh"};
1087
1088
1089
1090
        if(contains(attributes, "activations"))
        {
            auto names = attributes.at("activations").strings();
            vec_names.clear();
1091
            vec_names.resize(names.size());
Shucai Xiao's avatar
Shucai Xiao committed
1092
1093
1094
            std::transform(names.begin(), names.end(), vec_names.begin(), [](auto name) {
                return to_lower(name);
            });
1095
1096
        }

1097
1098
1099
        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
1100
        if(name_it != vec_names.end())
1101
1102
1103
        {
            MIGRAPHX_THROW("RNN: activation function " + std::string(*name_it) + " not supported");
        }
1104

Shucai Xiao's avatar
Shucai Xiao committed
1105
        // bidirectional case should have two activation functions.
Shucai Xiao's avatar
Shucai Xiao committed
1106
        // one is for forward, and the other is for reverse.
Shucai Xiao's avatar
Shucai Xiao committed
1107
        // if only one actv function is provided, we use it in both
1108
        // forward and reverse direction
1109
        if(dirct == op::rnn_direction::bidirectional)
1110
        {
Shucai Xiao's avatar
Shucai Xiao committed
1111
            if(vec_names.size() == 1)
1112
1113
1114
1115
1116
            {
                vec_names.push_back(vec_names.at(0));
            }
        }

Shucai Xiao's avatar
Shucai Xiao committed
1117
1118
1119
        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];
1120
        });
Shucai Xiao's avatar
Shucai Xiao committed
1121

Shucai Xiao's avatar
Shucai Xiao committed
1122
1123
1124
1125
1126
1127
1128
        // To be added later
        float clip = 0.0;
        if(contains(attributes, "clip"))
        {
            clip = parse_value(attributes.at("clip")).at<float>();
        }

1129
1130
        // if the number of arguments is less than 6, append
        // undefined operator to have 6 arguments
Shucai Xiao's avatar
Shucai Xiao committed
1131
        if(args.size() < 6)
1132
1133
1134
1135
1136
        {
            auto ins = prog.add_instruction(op::undefined{});
            args.insert(args.end(), (6 - args.size()), ins);
        }

Shucai Xiao's avatar
Shucai Xiao committed
1137
1138
        // 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
1139
                                                  std::move(args));
Shucai Xiao's avatar
Shucai Xiao committed
1140

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

Shucai Xiao's avatar
Shucai Xiao committed
1144
        return {hidden_states, last_output};
Shucai Xiao's avatar
Shucai Xiao committed
1145
1146
    }

1147
    std::vector<instruction_ref>
1148
1149
1150
1151
1152
1153
1154
    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
1155
            std::size_t hidden_size_att = parse_value(attributes.at("hidden_size")).at<int>();
Shucai Xiao's avatar
Shucai Xiao committed
1156
            if(hidden_size != hidden_size_att)
Shucai Xiao's avatar
Shucai Xiao committed
1157
1158
1159
            {
                MIGRAPHX_THROW("GRU: hidden size mismatch in input and attribute");
            }
1160
1161
1162
1163
1164
1165
1166
1167
1168
        }

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

1169
        op::rnn_direction dirct = op::rnn_direction::forward;
1170
1171
        if(direction == "bidirectional")
        {
1172
            dirct = op::rnn_direction::bidirectional;
1173
1174
1175
        }
        else if(direction == "reverse")
        {
1176
            dirct = op::rnn_direction::reverse;
1177
1178
        }

1179
        std::vector<std::string> vec_names = {"sigmoid", "tanh"};
1180
1181
        if(contains(attributes, "activations"))
        {
1182
            auto names = attributes.at("activations").strings();
1183
            vec_names.clear();
Shucai Xiao's avatar
Shucai Xiao committed
1184
            vec_names.resize(names.size());
Shucai Xiao's avatar
Shucai Xiao committed
1185
1186
1187
            std::transform(names.begin(), names.end(), vec_names.begin(), [](auto name) {
                return to_lower(name);
            });
1188
1189
        }

1190
        // need 4 activation functions
1191
        if(dirct == op::rnn_direction::bidirectional)
1192
        {
Shucai Xiao's avatar
Shucai Xiao committed
1193
            // 4 activation functions are used in the bidirectional
1194
            // scenario. No spec is provided in onnx::operator. we
Shucai Xiao's avatar
Shucai Xiao committed
1195
1196
            // use the algorithm that: if 1 actv function is provided,
            // repeat 1 four times. If 2 actv functins are provided,
1197
1198
            // 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
1199
1200
1201
            // assume the 3rd one is repeated once and used by the
            // reverse direction.
            // This may need change later
1202
            if(vec_names.size() == 1)
1203
            {
1204
                vec_names.insert(vec_names.end(), 3, vec_names.at(0));
1205
            }
1206
            else if(vec_names.size() == 2)
1207
            {
1208
1209
1210
                // repeat the activation functions
                vec_names.push_back(vec_names.at(0));
                vec_names.push_back(vec_names.at(1));
1211
            }
1212
            else if(vec_names.size() == 3)
1213
            {
1214
                vec_names.push_back(vec_names.at(2));
1215
1216
            }
        }
Shucai Xiao's avatar
Shucai Xiao committed
1217
        else
1218
        {
1219
            if(vec_names.size() == 1)
1220
            {
1221
                vec_names.push_back(vec_names.at(0));
1222
1223
1224
            }
        }

1225
1226
1227
        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
1228
        if(name_it != vec_names.end())
1229
1230
1231
        {
            MIGRAPHX_THROW("GRU: activation function " + std::string(*name_it) + " not supported");
        }
1232

Shucai Xiao's avatar
Shucai Xiao committed
1233
1234
1235
        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
1236
        });
1237
1238
1239
1240
1241
1242
1243
1244

        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
1245
        if(contains(attributes, "linear_before_reset"))
1246
1247
1248
1249
        {
            linear_before_reset = parse_value(attributes.at("linear_before_reset")).at<int>();
        }

Shucai Xiao's avatar
Shucai Xiao committed
1250
        // append undefined opeator to make 6 arguments
Shucai Xiao's avatar
Shucai Xiao committed
1251
        if(args.size() < 6)
Shucai Xiao's avatar
Shucai Xiao committed
1252
1253
1254
1255
1256
        {
            auto ins = prog.add_instruction(op::undefined{});
            args.insert(args.end(), 6 - args.size(), ins);
        }

1257
1258
        // first output for concatenation of hidden states
        auto hidden_states = prog.add_instruction(
Shucai Xiao's avatar
Shucai Xiao committed
1259
            op::gru{hidden_size, vec_actv_funcs, dirct, clip, linear_before_reset},
Shucai Xiao's avatar
Shucai Xiao committed
1260
            std::move(args));
1261
1262

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

Shucai Xiao's avatar
Shucai Xiao committed
1265
        return {hidden_states, last_output};
1266
1267
    }

Shucai Xiao's avatar
Shucai Xiao committed
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
    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
1290
        op::rnn_direction dirct = op::rnn_direction::forward;
Shucai Xiao's avatar
Shucai Xiao committed
1291
1292
        if(direction == "bidirectional")
        {
Shucai Xiao's avatar
Shucai Xiao committed
1293
            dirct = op::rnn_direction::bidirectional;
Shucai Xiao's avatar
Shucai Xiao committed
1294
1295
1296
        }
        else if(direction == "reverse")
        {
Shucai Xiao's avatar
Shucai Xiao committed
1297
            dirct = op::rnn_direction::reverse;
Shucai Xiao's avatar
Shucai Xiao committed
1298
        }
Shucai Xiao's avatar
Shucai Xiao committed
1299
        else if(direction == "forward")
Shucai Xiao's avatar
Shucai Xiao committed
1300
        {
Shucai Xiao's avatar
Shucai Xiao committed
1301
            dirct = op::rnn_direction::forward;
Shucai Xiao's avatar
Shucai Xiao committed
1302
1303
1304
1305
1306
1307
        }
        else
        {
            MIGRAPHX_THROW("LSTM: incorrect direction attribute");
        }

1308
        std::vector<std::string> vec_names = {"sigmoid", "tanh", "tanh"};
Shucai Xiao's avatar
Shucai Xiao committed
1309
1310
1311
1312
1313
        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
1314
1315
1316
            std::transform(names.begin(), names.end(), vec_names.begin(), [](auto name) {
                return to_lower(name);
            });
Shucai Xiao's avatar
Shucai Xiao committed
1317
1318
1319
        }

        // need 6 activation functions for bidirectional directions
Shucai Xiao's avatar
Shucai Xiao committed
1320
        if(dirct == op::rnn_direction::bidirectional)
Shucai Xiao's avatar
Shucai Xiao committed
1321
1322
1323
1324
1325
1326
        {
            // 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
1327
            // if 3 actv funcs are provide, repeat all three once.
Shucai Xiao's avatar
Shucai Xiao committed
1328
1329
1330
1331
            // the same algorithm is used for 4, 5, and 6 actv funcions
            // provided. This may need change later
            switch(vec_names.size())
            {
1332
            case 1:
Shucai Xiao's avatar
Shucai Xiao committed
1333
1334
1335
1336
1337
1338
                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)};
1339
                break;
Shucai Xiao's avatar
Shucai Xiao committed
1340
1341
1342

            case 2:
                // repeat the 2nd actv func once, then repeat all three another time
Shucai Xiao's avatar
Shucai Xiao committed
1343
1344
1345
1346
1347
1348
                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
1349
1350
1351
1352
                break;

            case 3:
                // repeat all three actv funcs once
Shucai Xiao's avatar
Shucai Xiao committed
1353
1354
1355
1356
1357
1358
                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
1359
1360
                break;

Shucai Xiao's avatar
Shucai Xiao committed
1361
1362
1363
1364
1365
1366
1367
            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)};
1368
                break;
Shucai Xiao's avatar
Shucai Xiao committed
1369

Shucai Xiao's avatar
Shucai Xiao committed
1370
1371
1372
1373
1374
1375
1376
            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)};
1377
                break;
Shucai Xiao's avatar
Shucai Xiao committed
1378

Shucai Xiao's avatar
Shucai Xiao committed
1379
            default: break;
Shucai Xiao's avatar
Shucai Xiao committed
1380
1381
1382
1383
1384
1385
            }
        }
        else
        {
            switch(vec_names.size())
            {
Shucai Xiao's avatar
Shucai Xiao committed
1386
            case 1: vec_names = {vec_names.at(0), vec_names.at(0), vec_names.at(0)}; break;
Shucai Xiao's avatar
Shucai Xiao committed
1387
1388
1389

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

Shucai Xiao's avatar
Shucai Xiao committed
1393
            default: break;
Shucai Xiao's avatar
Shucai Xiao committed
1394
1395
1396
            }
        }

1397
1398
1399
        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
1400
        if(name_it != vec_names.end())
1401
1402
1403
        {
            MIGRAPHX_THROW("LSTM: activation function " + std::string(*name_it) + " not supported");
        }
Shucai Xiao's avatar
Shucai Xiao committed
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425

        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
1426
            args.insert(args.end(), 8 - args.size(), ins);
Shucai Xiao's avatar
Shucai Xiao committed
1427
1428
1429
1430
        }

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

        // second output for last lstm output
Shucai Xiao's avatar
Shucai Xiao committed
1434
        auto last_output = prog.add_instruction(op::rnn_last_output{}, hidden_states);
Shucai Xiao's avatar
Shucai Xiao committed
1435
1436
1437
1438
1439
1440

        // 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};
    }
1441

Shucai Xiao's avatar
Shucai Xiao committed
1442
    template <class T>
Shucai Xiao's avatar
Shucai Xiao committed
1443
    instruction_ref parse_reduce_oper(const std::string&,
Shucai Xiao's avatar
Shucai Xiao committed
1444
1445
                                      attribute_map attributes,
                                      std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
1446
1447
1448
1449
    {
        std::size_t n_dim = args.front()->get_shape().lens().size();

        // default to reduce over all dimensions
1450
        std::vector<int64_t> axes(n_dim);
Shucai Xiao's avatar
Shucai Xiao committed
1451
1452
1453
1454
1455
        std::iota(axes.begin(), axes.end(), 0);
        if(contains(attributes, "axes"))
        {
            axes.clear();
            auto&& attr_axes = attributes["axes"].ints();
1456
            axes             = std::vector<int64_t>(attr_axes.begin(), attr_axes.end());
Shucai Xiao's avatar
Shucai Xiao committed
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
        }

        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
1467
            return prog.add_instruction(T{axes}, std::move(args));
Shucai Xiao's avatar
Shucai Xiao committed
1468
1469
1470
        }
        else
        {
Shucai Xiao's avatar
Shucai Xiao committed
1471
            auto ins = prog.add_instruction(T{axes}, std::move(args));
1472
            return prog.add_instruction(op::squeeze{axes}, ins);
1473
1474
        }
    }
1475

Shucai Xiao's avatar
Shucai Xiao committed
1476
1477
    instruction_ref
    parse_cast(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
1478
    {
Shucai Xiao's avatar
Shucai Xiao committed
1479
        if(!contains(attributes, "to"))
1480
1481
1482
1483
        {
            MIGRAPHX_THROW("PARSE_CAST: missing to type attribute!");
        }

Shucai Xiao's avatar
Shucai Xiao committed
1484
        int to_type        = parse_value(attributes.at("to")).at<int>();
1485
1486
1487
        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
1488

Paul's avatar
Paul committed
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
    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
1501
            MIGRAPHX_THROW("Failed reading onnx file.");
Paul's avatar
Paul committed
1502
1503
1504
1505
1506
1507
        }
    }

    void parse_graph(const onnx::GraphProto& graph)
    {
        nodes = get_nodes(graph);
1508
1509
1510
1511
1512
        std::unordered_map<std::string, onnx::TensorProto> initializer_data;
        for(auto&& f : graph.initializer())
        {
            initializer_data[f.name()] = f;
        }
Paul's avatar
Paul committed
1513
1514
1515
        for(auto&& input : graph.input())
        {
            const std::string& name = input.name();
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
            // 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
1528
        }
Paul's avatar
Paul committed
1529
        for(auto&& output : graph.output())
Paul's avatar
Paul committed
1530
        {
Paul's avatar
Paul committed
1531
            this->parse_node(output.name());
Paul's avatar
Paul committed
1532
1533
1534
        }
    }

Shucai Xiao's avatar
Shucai Xiao committed
1535
    void parse_undefined(const std::string& name)
1536
    {
Shucai Xiao's avatar
Shucai Xiao committed
1537
        auto ins           = prog.add_instruction(op::undefined{});
1538
1539
1540
        instructions[name] = ins;
    }

Paul's avatar
Paul committed
1541
    void parse_node(const std::string& name)
Paul's avatar
Paul committed
1542
    {
Paul's avatar
Paul committed
1543
        if(name.empty())
Paul's avatar
Paul committed
1544
            MIGRAPHX_THROW("Onnx node must have a name");
Paul's avatar
Paul committed
1545
1546
1547
1548
1549
1550
1551
1552
        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
1553
1554
                    assert(name != input);
                    this->parse_node(input);
Paul's avatar
Paul committed
1555
                }
Shucai Xiao's avatar
Shucai Xiao committed
1556
                else if(input.empty())
Paul's avatar
Paul committed
1557
                {
1558
                    this->parse_undefined(input);
Paul's avatar
Paul committed
1559
                }
1560
                args.push_back(instructions.at(input));
Paul's avatar
Paul committed
1561
            }
Paul's avatar
Paul committed
1562
            std::vector<instruction_ref> result;
Paul's avatar
Paul committed
1563
1564
            if(ops.count(node.op_type()) == 0)
            {
1565
                result.push_back(prog.add_instruction(op::unknown{node.op_type()}, args));
Paul's avatar
Paul committed
1566
1567
1568
            }
            else
            {
Paul's avatar
Paul committed
1569
                result = ops[node.op_type()](get_attributes(node), args);
Paul's avatar
Paul committed
1570
            }
Paul's avatar
Paul committed
1571
            // Even no output nodes produce output in migraphx
Paul's avatar
Paul committed
1572
            if(node.output().empty() and result.size() == 1)
Paul's avatar
Paul committed
1573
1574
            {
                instructions[name] = result.front();
Paul's avatar
Paul committed
1575
1576
1577
            }
            else
            {
Paul's avatar
Paul committed
1578
1579
1580
1581
1582
1583
                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
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
            }
        }
    }

    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
1601
        std::size_t n = 0;
Paul's avatar
Paul committed
1602
1603
        for(auto&& node : graph.node())
        {
Paul's avatar
Paul committed
1604
            if(node.output().empty())
Paul's avatar
Paul committed
1605
            {
Paul's avatar
Paul committed
1606
                if(node.name().empty())
Paul's avatar
Paul committed
1607
1608
1609
1610
1611
1612
1613
1614
1615
                {
                    result["migraphx_unamed_node_" + std::to_string(n)] = node;
                    n++;
                }
                else
                {
                    result[node.name()] = node;
                }
            }
Paul's avatar
Paul committed
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
            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
1641
        case onnx::AttributeProto::FLOATS: return from_repeated(shape::float_type, attr.floats());
Paul's avatar
Paul committed
1642
1643
1644
1645
1646
        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
1647
        MIGRAPHX_THROW("Invalid attribute type");
Paul's avatar
Paul committed
1648
1649
1650
1651
1652
    }

    static literal parse_tensor(const onnx::TensorProto& t)
    {
        std::vector<std::size_t> dims(t.dims().begin(), t.dims().end());
1653
1654
        if(t.has_raw_data())
        {
wsttiger's avatar
wsttiger committed
1655
            const std::string& s = t.raw_data();
Scott Thornton's avatar
Scott Thornton committed
1656
1657
1658
            switch(t.data_type())
            {
            case onnx::TensorProto::UNDEFINED: throw std::runtime_error("");
1659
            case onnx::TensorProto::FLOAT: return create_literal(shape::float_type, dims, s.data());
Scott Thornton's avatar
Scott Thornton committed
1660
            case onnx::TensorProto::UINT8: throw std::runtime_error("");
1661
            case onnx::TensorProto::INT8: return create_literal(shape::int32_type, dims, s.data());
Khalique's avatar
Khalique committed
1662
1663
            case onnx::TensorProto::UINT16:
                return create_literal(shape::int32_type, dims, s.data());
1664
1665
1666
            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
1667
            case onnx::TensorProto::STRING: throw std::runtime_error("");
1668
            case onnx::TensorProto::BOOL: return create_literal(shape::int32_type, dims, s.data());
Khalique's avatar
Khalique committed
1669
1670
1671
1672
            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
1673
1674
1675
1676
1677
            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
1678
            MIGRAPHX_THROW("Invalid tensor type");
1679
        }
Paul's avatar
Paul committed
1680
1681
1682
1683
        switch(t.data_type())
        {
        case onnx::TensorProto::UNDEFINED: throw std::runtime_error("");
        case onnx::TensorProto::FLOAT:
Khalique's avatar
Khalique committed
1684
            return create_literal(shape::float_type, dims, t.float_data());
Paul's avatar
Paul committed
1685
1686
        case onnx::TensorProto::UINT8: throw std::runtime_error("");
        case onnx::TensorProto::INT8:
Khalique's avatar
Khalique committed
1687
            return create_literal(shape::int32_type, dims, t.int32_data());
Paul's avatar
Paul committed
1688
        case onnx::TensorProto::UINT16:
Khalique's avatar
Khalique committed
1689
            return create_literal(shape::int32_type, dims, t.int32_data());
Paul's avatar
Paul committed
1690
        case onnx::TensorProto::INT16:
Khalique's avatar
Khalique committed
1691
            return create_literal(shape::int32_type, dims, t.int32_data());
Paul's avatar
Paul committed
1692
        case onnx::TensorProto::INT32:
Khalique's avatar
Khalique committed
1693
            return create_literal(shape::int32_type, dims, t.int32_data());
Paul's avatar
Paul committed
1694
        case onnx::TensorProto::INT64:
Khalique's avatar
Khalique committed
1695
            return create_literal(shape::int64_type, dims, t.int64_data());
Paul's avatar
Paul committed
1696
1697
        case onnx::TensorProto::STRING: throw std::runtime_error("");
        case onnx::TensorProto::BOOL:
Khalique's avatar
Khalique committed
1698
            return create_literal(shape::int32_type, dims, t.int32_data());
Paul's avatar
Paul committed
1699
        case onnx::TensorProto::FLOAT16:
Khalique's avatar
Khalique committed
1700
        {
Khalique's avatar
Khalique committed
1701
            std::vector<uint16_t> data_uint16(t.int32_data().begin(), t.int32_data().end());
1702
            std::vector<half> data_half;
Khalique's avatar
Khalique committed
1703
1704
1705
            std::transform(data_uint16.begin(),
                           data_uint16.end(),
                           std::back_inserter(data_half),
1706
                           [](uint16_t raw_val) { return *reinterpret_cast<half*>(&raw_val); });
1707
            return create_literal(shape::half_type, dims, data_half);
Khalique's avatar
Khalique committed
1708
        }
Paul's avatar
Paul committed
1709
        case onnx::TensorProto::DOUBLE:
Khalique's avatar
Khalique committed
1710
            return create_literal(shape::double_type, dims, t.double_data());
Paul's avatar
Paul committed
1711
1712
1713
1714
1715
        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
1716
        MIGRAPHX_THROW("Invalid tensor type");
Paul's avatar
Paul committed
1717
1718
    }

Khalique's avatar
Khalique committed
1719
    static literal
1720
    create_literal(shape::type_t shape_type, const std::vector<size_t>& dims, const char* data)
1721
    {
Khalique's avatar
Khalique committed
1722
        // in case of scalar constants in onnx file, use dims=1 to fill initializer data
1723
        if(dims.empty())
1724
            return literal{{shape_type}, data};
1725
1726
1727
        return literal{{shape_type, dims}, data};
    }

1728
    template <class T, MIGRAPHX_REQUIRES(not std::is_pointer<T>{})>
Khalique's avatar
Khalique committed
1729
    static literal create_literal(shape::type_t shape_type, const std::vector<size_t>& dims, T data)
1730
1731
    {
        if(dims.empty())
1732
            return literal{{shape_type}, data.begin(), data.end()};
1733
        return literal{{shape_type, dims}, data.begin(), data.end()};
1734
1735
    }

Paul's avatar
Paul committed
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
    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
1755
        case onnx::TensorProto::FLOAT16: shape_type = shape::half_type; break;
Paul's avatar
Paul committed
1756
1757
1758
1759
1760
1761
1762
1763
1764
        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
1765
        auto&& tensor_dims = t.tensor_type().shape().dim();
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
        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
1777
1778
        return {shape_type, dims};
    }
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800

    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
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
};

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
1824
} // namespace MIGRAPHX_INLINE_NS
Paul's avatar
Paul committed
1825
} // namespace migraphx