onnx.cpp 102 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
#include <migraphx/fallthrough.hpp>
#include <migraphx/program.hpp>
14
#include <migraphx/make_op.hpp>
Paul's avatar
Paul committed
15
16
17
#include <migraphx/ranges.hpp>
#include <migraphx/instruction.hpp>
#include <migraphx/config.hpp>
18
#include <migraphx/onnx.hpp>
19
#include <migraphx/pad_calc.hpp>
Shucai Xiao's avatar
Shucai Xiao committed
20
21
#include <migraphx/type_traits.hpp>
#include <migraphx/float_equal.hpp>
Paul's avatar
Paul committed
22

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <migraphx/op/as_shape.hpp>
#include <migraphx/op/batch_norm_inference.hpp>
#include <migraphx/op/broadcast.hpp>
#include <migraphx/op/concat.hpp>
#include <migraphx/op/convert.hpp>
#include <migraphx/op/gather.hpp>
#include <migraphx/op/gru.hpp>
#include <migraphx/op/lrn.hpp>
#include <migraphx/op/lstm.hpp>
#include <migraphx/op/multibroadcast.hpp>
#include <migraphx/op/pad.hpp>
#include <migraphx/op/reshape.hpp>
#include <migraphx/op/rnn.hpp>
#include <migraphx/op/rnn_last_cell_output.hpp>
#include <migraphx/op/rnn_last_hs_output.hpp>
#include <migraphx/op/rnn_variable_seq_lens.hpp>
#include <migraphx/op/rnn_var_sl_last_output.hpp>
#include <migraphx/op/scalar.hpp>
#include <migraphx/op/slice.hpp>
#include <migraphx/op/squeeze.hpp>
#include <migraphx/op/transpose.hpp>
#include <migraphx/op/undefined.hpp>
#include <migraphx/op/unknown.hpp>
#include <migraphx/op/unsqueeze.hpp>

Paul's avatar
Paul committed
48
namespace migraphx {
Paul's avatar
Paul committed
49
inline namespace MIGRAPHX_INLINE_NS {
Paul's avatar
Paul committed
50

51
52
namespace onnx = onnx_for_migraphx;

Paul's avatar
Paul committed
53
54
55
struct onnx_parser
{
    using attribute_map = std::unordered_map<std::string, onnx::AttributeProto>;
56
57
58
59
60
61
    struct node_info
    {
        attribute_map attributes{};
        std::size_t num_outputs = 1;
    };
    using node_map = std::unordered_map<std::string, onnx::NodeProto>;
Paul's avatar
Paul committed
62
    using op_func =
63
        std::function<std::vector<instruction_ref>(node_info, std::vector<instruction_ref>)>;
Paul's avatar
Paul committed
64
65
    node_map nodes;
    std::unordered_map<std::string, instruction_ref> instructions;
66
67
68
69
    program prog                  = program();
    bool is_pytorch               = false;
    std::size_t default_dim_value = 1;
    std::unordered_map<std::string, std::vector<std::size_t>> map_input_dims;
70
    bool skip_unknown_operators = false;
Paul's avatar
Paul committed
71
72

    std::unordered_map<std::string, op_func> ops;
73
    std::unordered_map<std::string, operation> map_actv_funcs;
Paul's avatar
Paul committed
74
75
76

    onnx_parser()
    {
77
        // sort onnx operator alphabetically through name
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
        add_generic_op("Abs", "abs");
        add_generic_op("Acos", "acos");
        add_generic_op("Acosh", "acosh");
        add_generic_op("Asin", "asin");
        add_generic_op("Asinh", "asinh");
        add_generic_op("Atan", "atan");
        add_generic_op("Atanh", "atanh");
        add_generic_op("Ceil", "ceil");
        add_generic_op("Concat", "concat");
        add_generic_op("Cos", "cos");
        add_generic_op("Cosh", "cosh");
        add_generic_op("Dropout", "identity");
        add_generic_op("Erf", "erf");
        add_generic_op("Exp", "exp");
        add_generic_op("Flatten", "flatten");
        add_generic_op("Floor", "floor");
        add_generic_op("Gather", "gather", true);
        add_generic_op("Identity", "identity");
        add_generic_op("Log", "log");
        add_generic_op("LogSoftmax", "logsoftmax");
        add_generic_op("Neg", "neg");
        add_generic_op("Reciprocal", "recip");
        add_generic_op("Relu", "relu");
        add_generic_op("Round", "round");
        add_generic_op("Sigmoid", "sigmoid");
        add_generic_op("Sign", "sign");
        add_generic_op("Sin", "sin");
        add_generic_op("Sinh", "sinh");
        add_generic_op("Softmax", "softmax");
        add_generic_op("Sqrt", "sqrt");
        add_generic_op("Squeeze", "squeeze", true);
        add_generic_op("Tan", "tan");
        add_generic_op("Tanh", "tanh");
        add_generic_op("Unsqueeze", "unsqueeze", true);

        add_binary_op("Add", "add");
        add_binary_op("Div", "div");
        add_binary_op("Mul", "mul");
        add_binary_op("Pow", "pow");
        add_binary_op("PRelu", "prelu");
        add_binary_op("Sub", "sub");

        add_variadic_op("Sum", "add");
        add_variadic_op("Max", "max");
        add_variadic_op("Min", "min");
Paul's avatar
Paul committed
123

124
        add_mem_op("ATen", &onnx_parser::parse_aten);
125
        add_mem_op("AveragePool", &onnx_parser::parse_pooling);
126
127
        add_mem_op("ArgMax", "argmax", &onnx_parser::parse_arg_op);
        add_mem_op("ArgMin", "argmin", &onnx_parser::parse_arg_op);
128
        add_mem_op("BatchNormalization", &onnx_parser::parse_batchnorm);
129
        add_mem_op("Cast", &onnx_parser::parse_cast);
Khalique's avatar
Khalique committed
130
        add_mem_op("Clip", &onnx_parser::parse_clip);
Paul's avatar
Paul committed
131
        add_mem_op("Constant", &onnx_parser::parse_constant);
132
133
        add_mem_op("ConstantFill", &onnx_parser::parse_constant_fill);
        add_mem_op("ConstantOfShape", &onnx_parser::parse_constant_of_shape);
134
135
        add_mem_op("Conv", "convolution", &onnx_parser::parse_conv);
        add_mem_op("ConvInteger", "quant_convolution", &onnx_parser::parse_conv);
kahmed10's avatar
kahmed10 committed
136
        add_mem_op("ConvTranspose", &onnx_parser::parse_conv_transpose);
137
        add_mem_op("Elu", &onnx_parser::parse_elu);
138
        add_mem_op("Equal", &onnx_parser::parse_equal);
139
        add_mem_op("Expand", &onnx_parser::parse_expand);
Shucai Xiao's avatar
Shucai Xiao committed
140
        add_mem_op("GatherElements", &onnx_parser::parse_gather_elements);
Paul's avatar
Paul committed
141
        add_mem_op("Gemm", &onnx_parser::parse_gemm);
142
143
144
145
        add_mem_op("GlobalAveragePool", &onnx_parser::parse_pooling);
        add_mem_op("GlobalMaxPool", &onnx_parser::parse_pooling);
        add_mem_op("GRU", &onnx_parser::parse_gru);
        add_mem_op("ImageScaler", &onnx_parser::parse_imagescaler);
kahmed10's avatar
kahmed10 committed
146
        add_mem_op("InstanceNormalization", &onnx_parser::parse_instancenorm);
147
148
        add_mem_op("LeakyRelu", &onnx_parser::parse_leaky_relu);
        add_mem_op("LRN", &onnx_parser::parse_lrn);
149
        add_mem_op("LSTM", &onnx_parser::parse_lstm);
150
151
        add_mem_op("MatMul", "dot", &onnx_parser::parse_matmul);
        add_mem_op("MatMulInteger", "quant_dot", &onnx_parser::parse_matmul);
152
        add_mem_op("MaxPool", &onnx_parser::parse_pooling);
Shucai Xiao's avatar
Shucai Xiao committed
153
        add_mem_op("NonZero", &onnx_parser::parse_nonzero);
kahmed10's avatar
kahmed10 committed
154
        add_mem_op("OneHot", &onnx_parser::parse_onehot);
155
        add_mem_op("Pad", &onnx_parser::parse_pad);
kahmed10's avatar
kahmed10 committed
156
        add_mem_op("Range", &onnx_parser::parse_range);
Shucai Xiao's avatar
Shucai Xiao committed
157
158
159
160
        add_mem_op("ReduceL1", &onnx_parser::parse_reduce_l1);
        add_mem_op("ReduceL2", &onnx_parser::parse_reduce_l2);
        add_mem_op("ReduceLogSum", &onnx_parser::parse_reduce_log_sum);
        add_mem_op("ReduceLogSumExp", &onnx_parser::parse_reduce_log_sum_exp);
161
162
163
164
165
        add_mem_op("ReduceMax", "reduce_max", &onnx_parser::parse_reduce_oper);
        add_mem_op("ReduceMean", "reduce_mean", &onnx_parser::parse_reduce_oper);
        add_mem_op("ReduceMin", "reduce_min", &onnx_parser::parse_reduce_oper);
        add_mem_op("ReduceProd", "reduce_prod", &onnx_parser::parse_reduce_oper);
        add_mem_op("ReduceSum", "reduce_sum", &onnx_parser::parse_reduce_oper);
Shucai Xiao's avatar
Shucai Xiao committed
166
        add_mem_op("ReduceSumSquare", &onnx_parser::parse_reduce_sum_square);
167
168
169
170
        add_mem_op("Reshape", &onnx_parser::parse_reshape);
        add_mem_op("RNN", &onnx_parser::parse_rnn);
        add_mem_op("Shape", &onnx_parser::parse_shape);
        add_mem_op("Slice", &onnx_parser::parse_slice);
171
        add_mem_op("Split", &onnx_parser::parse_split);
kahmed10's avatar
kahmed10 committed
172
        add_mem_op("Tile", &onnx_parser::parse_tile);
173
        add_mem_op("Transpose", &onnx_parser::parse_transpose);
174
175
176
177
178
179
180

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

    void init_actv_func()
    {
181
        // Support name format of all lower case or the first letter capital
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
        map_actv_funcs.insert(std::make_pair("tanh", make_op("tanh")));
        map_actv_funcs.insert(std::make_pair("relu", make_op("relu")));
        map_actv_funcs.insert(std::make_pair("sigmoid", make_op("sigmoid")));
        map_actv_funcs.insert(std::make_pair("leakyrelu", make_op("leaky_relu")));
        map_actv_funcs.insert(std::make_pair("elu", make_op("elu")));
    }

    static operation load(const std::string& name, const node_info& info)
    {
        auto op = make_op(name);
        auto v  = op.to_value();
        for(auto&& x : v)
        {
            if(info.attributes.count(x.get_key()) == 0)
                continue;
            literal s = parse_value(info.attributes.at(x.get_key()));
            if(x.is_array())
            {
                std::vector<value> values;
                s.visit([&](auto y) {
                    std::transform(y.begin(), y.end(), std::back_inserter(values), [](auto z) {
                        return value(z);
                    });
                });
                x = values;
            }
            else
            {
                s.visit([&](auto y) { x = y.front(); });
            }
        }
        op.from_value(v);
        return op;
Paul's avatar
Paul committed
215
216
217
218
    }

    template <class F>
    void add_op(std::string name, F f)
Paul's avatar
Paul committed
219
220
221
222
223
224
225
226
227
    {
        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
228
229
230
231
232
    {
        ops.emplace(name, f);
    }

    template <class F>
233
    void add_mem_op(const std::string& name, F f)
Paul's avatar
Paul committed
234
    {
Paul's avatar
Paul committed
235
        add_op(name, [=](auto&&... xs) {
Paul's avatar
Paul committed
236
237
238
            return std::mem_fn(f)(*this, name, std::forward<decltype(xs)>(xs)...);
        });
    }
Khalique's avatar
Khalique committed
239

240
241
242
243
244
245
246
247
248
    template <class F>
    void add_mem_op(const std::string& onnx_name, const std::string& op_name, F f)
    {
        add_op(onnx_name, [=](auto&&... xs) {
            return std::mem_fn(f)(*this, onnx_name, op_name, std::forward<decltype(xs)>(xs)...);
        });
    }

    void add_binary_op(const std::string& onnx_name, const std::string& op_name)
249
    {
250
        add_op(onnx_name, [this, op_name](node_info info, std::vector<instruction_ref> args) {
Scott Thornton's avatar
Scott Thornton committed
251
            if(args.size() != 2)
Paul's avatar
Paul committed
252
                MIGRAPHX_THROW("binary operators should have 2 operands");
253
            if(contains(info.attributes, "broadcast") and contains(info.attributes, "axis"))
254
            {
255
                uint64_t broadcasted = parse_value(info.attributes.at("broadcast")).at<uint64_t>();
256
257
                if(broadcasted != 0)
                {
258
                    uint64_t axis = parse_value(info.attributes.at("axis")).at<uint64_t>();
Shucai Xiao's avatar
Shucai Xiao committed
259
260
                    auto l = prog.add_instruction(op::broadcast{axis, args[0]->get_shape().lens()},
                                                  args[1]);
261
                    return prog.add_instruction(make_op(op_name), args[0], l);
262
                }
263
                return prog.add_instruction(make_op(op_name), args);
264
            }
Paul's avatar
Paul committed
265
            else
266
            {
267
                return add_broadcastable_binary_op(args[0], args[1], op_name);
268
269
270
271
            }
        });
    }

Shucai Xiao's avatar
Shucai Xiao committed
272
273
    std::vector<std::size_t> compute_broadcasted_lens(std::vector<std::size_t> s0,
                                                      std::vector<std::size_t> s1)
274
275
276
277
278
279
280
281
282
283
284
285
286
    {
        // 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
287
        if(s0.size() > s1.size())
288
289
290
291
292
293
        {
            s0.swap(s1);
        }

        std::vector<std::size_t> out_lens(s1);
        auto offset = s1.size() - s0.size();
Shucai Xiao's avatar
Shucai Xiao committed
294
295
296
297
        std::transform(s0.begin(),
                       s0.end(),
                       s1.begin() + offset,
                       out_lens.begin() + offset,
298
                       [&](auto a, auto b) {
Shucai Xiao's avatar
Shucai Xiao committed
299
                           if(a != b and a != 1 and b != 1)
300
                           {
Shucai Xiao's avatar
Shucai Xiao committed
301
302
303
304
305
306
                               MIGRAPHX_THROW("COMPUTE_BROADCASTLEN: shape {" +
                                              to_string_range(s0) + "} and {" +
                                              to_string_range(s1) + "} mismatch!");
                           }
                           return std::max(a, b);
                       });
307
308
309
310

        return out_lens;
    }

Shucai Xiao's avatar
Shucai Xiao committed
311
312
    instruction_ref make_contiguous(instruction_ref ins)
    {
Shucai Xiao's avatar
Shucai Xiao committed
313
        if(ins->get_shape().standard())
Shucai Xiao's avatar
Shucai Xiao committed
314
315
316
317
        {
            return ins;
        }

318
        return prog.add_instruction(make_op("contiguous"), ins);
Shucai Xiao's avatar
Shucai Xiao committed
319
320
    }

321
322
    instruction_ref
    add_broadcastable_binary_op(instruction_ref arg0, instruction_ref arg1, const std::string& name)
Khalique's avatar
Khalique committed
323
    {
Khalique's avatar
Khalique committed
324
        if(arg0->get_shape().lens() != arg1->get_shape().lens())
Khalique's avatar
Khalique committed
325
326
        {
            // Get lengths for both arguments
Shucai Xiao's avatar
Shucai Xiao committed
327
328
            auto s0       = arg0->get_shape().lens();
            auto s1       = arg1->get_shape().lens();
329
            auto out_lens = compute_broadcasted_lens(s0, s1);
330
331
332
333
334
335
336
337
338

            auto l0 = arg0;
            if(arg0->get_shape().lens() != out_lens)
                l0 = prog.add_instruction(op::multibroadcast{out_lens}, arg0);

            auto l1 = arg1;
            if(arg1->get_shape().lens() != out_lens)
                l1 = prog.add_instruction(op::multibroadcast{out_lens}, arg1);

339
            return prog.add_instruction(make_op(name), l0, l1);
Khalique's avatar
Khalique committed
340
341
342
        }
        else
        {
343
            return prog.add_instruction(make_op(name), {arg0, arg1});
Khalique's avatar
Khalique committed
344
        }
345
346
    }

347
348
349
    void add_generic_op(const std::string& onnx_name,
                        const std::string& op_name,
                        bool contiguous = false)
Paul's avatar
Paul committed
350
    {
351
352
353
354
355
356
357
358
359
360
361
362
        add_op(
            onnx_name,
            [this, op_name, contiguous](const node_info& info, std::vector<instruction_ref> args) {
                auto op = load(op_name, info);
                if(contiguous)
                {
                    std::transform(args.begin(), args.end(), args.begin(), [&](auto arg) {
                        return this->make_contiguous(arg);
                    });
                }
                return prog.add_instruction(op, args);
            });
Paul's avatar
Paul committed
363
364
    }

365
    void add_variadic_op(const std::string& onnx_name, const std::string& op_name)
Khalique's avatar
Khalique committed
366
    {
367
        add_op(onnx_name, [this, op_name](const node_info&, std::vector<instruction_ref> args) {
Khalique's avatar
Khalique committed
368
            return std::accumulate(std::next(args.begin()),
Khalique's avatar
Khalique committed
369
370
                                   args.end(),
                                   args.front(),
371
372
                                   [this, op_name](instruction_ref a, instruction_ref b) {
                                       return add_broadcastable_binary_op(a, b, op_name);
Khalique's avatar
Khalique committed
373
                                   });
Khalique's avatar
Khalique committed
374
        });
Khalique's avatar
Khalique committed
375
376
    }

kahmed10's avatar
kahmed10 committed
377
378
379
380
381
382
383
384
385
386
387
388
389
390
    template <class T>
    std::vector<int64_t> to_int64_vector(const std::vector<T>& input_vector)
    {
        std::vector<int64_t> output_vector(input_vector.begin(), input_vector.end());
        return output_vector;
    }

    instruction_ref
    add_bias(const std::vector<instruction_ref>& args, instruction_ref curr_ins, uint64_t axis)
    {
        if(args.size() == 3)
        {
            auto bias_bcast =
                prog.add_instruction(op::broadcast{axis, curr_ins->get_shape().lens()}, args[2]);
391
            return prog.add_instruction(make_op("add"), curr_ins, bias_bcast);
kahmed10's avatar
kahmed10 committed
392
393
394
395
        }
        return curr_ins;
    }

396
    static bool is_asym_padding(const std::vector<int64_t>& padding)
397
    {
398
399
400
401
402
403
404
        assert(padding.size() % 2 == 0);
        size_t pad_ndims = padding.size() / 2;

        for(size_t i = 0; i < pad_ndims; i++)
        {
            if(padding[i] != padding[i + pad_ndims])
            {
kahmed10's avatar
kahmed10 committed
405
                return true;
406
407
            }
        }
kahmed10's avatar
kahmed10 committed
408
409
        return false;
    }
410

kahmed10's avatar
kahmed10 committed
411
412
    void check_asym_padding(instruction_ref& ins,
                            const std::vector<int64_t>& padding,
413
                            value& v,
414
415
                            int count_include_pad = 0,
                            float pad_val         = 0)
kahmed10's avatar
kahmed10 committed
416
417
418
419
420
    {
        size_t pad_ndims  = padding.size() / 2;
        auto left_pad_it  = padding.begin();
        auto right_pad_it = left_pad_it + pad_ndims;

421
        if(is_asym_padding(padding) or count_include_pad == 1)
422
        {
423
424
425
426
427
428
            std::vector<int64_t> asym_pads{0, 0, 0, 0}; // don't pad N and C
            // add left pads
            asym_pads.insert(asym_pads.begin() + 2, left_pad_it, right_pad_it);
            // add right pads
            asym_pads.insert(asym_pads.begin() + pad_ndims + 4, right_pad_it, padding.end());
            ins = prog.add_instruction(op::pad{asym_pads, pad_val}, ins);
429
430
431
        }
        else
        {
432
            v["padding"] = std::vector<size_t>(left_pad_it, right_pad_it);
433
434
435
        }
    }

436
437
    instruction_ref
    parse_clip(const std::string&, node_info info, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
438
    {
kahmed10's avatar
kahmed10 committed
439
440
441
442
443
444
445
        auto input_lens = args[0]->get_shape().lens();
        instruction_ref min_arg;
        instruction_ref max_arg;
        bool min_used = false;
        bool max_used = false;

        if(args.size() == 3)
Khalique's avatar
Khalique committed
446
        {
kahmed10's avatar
kahmed10 committed
447
448
449
450
            min_arg  = args[1];
            max_arg  = args[2];
            min_used = true;
            max_used = true;
Khalique's avatar
Khalique committed
451
        }
kahmed10's avatar
kahmed10 committed
452
        else if(args.size() == 2)
Khalique's avatar
Khalique committed
453
        {
kahmed10's avatar
kahmed10 committed
454
455
456
457
458
459
460
461
462
463
464
465
466
            min_arg  = args[1];
            min_used = true;
        }
        // if using previous opset for attributes
        else if(contains(info.attributes, "min") and contains(info.attributes, "max"))
        {

            float min_val = parse_value(info.attributes.at("min")).at<float>();
            float max_val = parse_value(info.attributes.at("max")).at<float>();
            min_arg       = prog.add_literal(min_val);
            max_arg       = prog.add_literal(max_val);
            min_used      = true;
            max_used      = true;
Khalique's avatar
Khalique committed
467
        }
kahmed10's avatar
kahmed10 committed
468
469
470
471
472
473
474
475

        if(min_used)
            min_arg = prog.add_instruction(op::multibroadcast{input_lens}, min_arg);

        if(max_used)
            max_arg = prog.add_instruction(op::multibroadcast{input_lens}, max_arg);

        if(min_used and max_used)
476
            return prog.add_instruction(make_op("clip"), args[0], min_arg, max_arg);
kahmed10's avatar
kahmed10 committed
477
        if(min_used)
478
            return prog.add_instruction(make_op("max"), args[0], min_arg);
479

480
        return prog.add_instruction(make_op("identity"), args[0]);
Shucai Xiao's avatar
Shucai Xiao committed
481
482
    }

483
484
485
486
    instruction_ref parse_arg_op(const std::string&,
                                 const std::string& op_name,
                                 node_info info,
                                 std::vector<instruction_ref> args)
487
    {
488
        int64_t axis = 0;
489
        if(contains(info.attributes, "axis"))
490
        {
491
            axis = static_cast<int64_t>(parse_value(info.attributes.at("axis")).at<int>());
492
493
        }

Shucai Xiao's avatar
Shucai Xiao committed
494
        int keep_dims = 1;
495
        if(contains(info.attributes, "keepdims"))
Shucai Xiao's avatar
Shucai Xiao committed
496
        {
497
            keep_dims = parse_value(info.attributes.at("keepdims")).at<int>();
Shucai Xiao's avatar
Shucai Xiao committed
498
499
        }

Shucai Xiao's avatar
Shucai Xiao committed
500
        if(keep_dims == 0)
501
        {
502
            auto ins = prog.add_instruction(make_op(op_name, {{"axis", axis}}), std::move(args));
503
            return prog.add_instruction(op::squeeze{{axis}}, ins);
504
505
506
        }
        else
        {
507
            return prog.add_instruction(make_op(op_name, {{"axis", axis}}), std::move(args));
508
        }
509
510
    }

kahmed10's avatar
kahmed10 committed
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
    void calc_reflect_indices(std::vector<int>& indices, const int64_t num_dims)
    {
        int k         = 0;
        bool reversed = false;
        // in reflect padding, if the num_pads > num_dims,
        // compute the extra pad indices periodically, ex. ( 1, 2, 3, 2, 1, 0)
        for(int& idx : indices)
        {
            if(k == num_dims - 1)
                reversed = true;
            if(k == 0)
                reversed = false;
            if(reversed)
                k--;
            else
                k++;
            idx = k;
        }
    }

    instruction_ref reflect_pad(const std::vector<int64_t>& pads, instruction_ref input)
    {
        size_t num_dims = pads.size() / 2;
        std::vector<int> ldims(pads.begin(), pads.begin() + num_dims);
        std::vector<int> rdims(pads.begin() + num_dims, pads.end());
        assert(ldims.size() == rdims.size());

        std::vector<int64_t> axes(num_dims);
        std::iota(axes.begin(), axes.end(), int64_t{0});

        // iterate over dimensions, starting from lowest dimension
        for(int64_t i = num_dims - 1; i >= 0; i--)
        {
            auto axis   = i;
            auto lcount = ldims.at(i);
            auto rcount = rdims.at(i);
            if(lcount == 0 and rcount == 0) // no padding for current dim
                continue;

            // calculate starts and ends for each iteration since shape may change
            std::vector<size_t> dims = input->get_shape().lens();
            std::vector<int64_t> starts(axes.size(), 0);
            std::vector<int64_t> ends(dims.begin(), dims.end());
            std::vector<instruction_ref> slices;

            auto starts_it = starts.begin() + i;
            auto ends_it   = ends.begin() + i;
            auto dims_it   = dims.begin() + i;

            std::vector<int> l_indices(lcount);
            std::vector<int> r_indices(rcount);

            // compute slice indices in a periodic fashion
            calc_reflect_indices(l_indices, *dims_it);
            calc_reflect_indices(r_indices, *dims_it);

            for(int idx : l_indices)
            {
                *starts_it = idx;
                *ends_it   = *starts_it + 1;
                slices.push_back(prog.add_instruction(op::slice{axes, starts, ends}, input));
            }
            // when padding on the left side, the outermost pad should be at the beginning
            std::reverse(slices.begin(), slices.end());
            slices.push_back(input);
            for(int idx : r_indices)
            {
                *starts_it = *dims_it - idx - 1;
                *ends_it   = *starts_it + 1;
                slices.push_back(prog.add_instruction(op::slice{axes, starts, ends}, input));
            }
            input = prog.add_instruction(op::concat{axis}, slices);
        }
        return input;
    }

587
588
589
590
591
592
593
594
595
    void check_attr_sizes(size_t kdims, size_t attr_size, const std::string& error_msg)
    {
        if(kdims != attr_size)
        {
            MIGRAPHX_THROW(error_msg + " k-dims: " + to_string(kdims) +
                           " attribute size: " + to_string(attr_size));
        }
    }

596
    void recalc_conv_attributes(value& v, size_t kdims)
597
    {
598
        if(v["padding"].size() != kdims)
599
        {
600
601
            v["padding"].resize(kdims);
            std::fill_n(v["padding"].begin(), kdims, 0);
602
        }
603
        if(v["stride"].size() != kdims)
604
        {
605
606
            v["stride"].resize(kdims);
            std::fill_n(v["stride"].begin(), kdims, 1);
607
        }
608
        if(v["dilation"].size() != kdims)
609
        {
610
611
            v["dilation"].resize(kdims);
            std::fill_n(v["dilation"].begin(), kdims, 1);
612
613
614
        }
    }

615
    static void cal_auto_padding_size(node_info info,
616
                                      value& v,
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
                                      const std::vector<std::size_t>& k_lens,
                                      const std::vector<std::size_t>& dilation,
                                      const std::vector<std::size_t>& in_lens,
                                      std::vector<int64_t>& paddings)
    {
        size_t kdims = in_lens.size() - 2;
        assert(k_lens.size() == kdims and dilation.size() == kdims);

        if(!contains(info.attributes, "auto_pad"))
        {
            return;
        }

        auto auto_pad = info.attributes["auto_pad"].s();
        if(auto_pad.find("SAME") != std::string::npos)
        {
            bool is_same_upper = (auto_pad.find("SAME_UPPER") != std::string::npos);
            paddings.resize(2 * kdims);

            for(size_t i = 0; i < paddings.size() / 2; i++)
            {
                calculate_padding(i,
                                  paddings,
                                  in_lens[i + 2],
641
                                  v["stride"][i].to<int64_t>(),
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
                                  dilation[i],
                                  k_lens[i],
                                  is_same_upper);
            }
        }
    }

    static void check_padding_mode(node_info info, const std::string& op_name)
    {
        // ensure pads availabe only when auto_pad is "NOT_SET"
        if(contains(info.attributes, "pads") and contains(info.attributes, "auto_pad"))
        {
            auto s = info.attributes["auto_pad"].s();
            if(to_upper(s) != "NOTSET")
            {
                MIGRAPHX_THROW("PARSE_" + op_name +
                               ": auto_pad and padding cannot be specified simultaneously");
            }
        }
    }

663
664
665
666
    instruction_ref parse_conv(const std::string&,
                               const std::string& op_name,
                               node_info info,
                               std::vector<instruction_ref> args)
Paul's avatar
Paul committed
667
    {
668
669
        auto op      = make_op(op_name);
        auto values  = op.to_value();
670
671
        auto l0      = args[0];
        auto weights = args[1];
672
673
674
675
        auto in_lens = l0->get_shape().lens();
        assert(in_lens.size() > 2);
        auto kdims = in_lens.size() - 2;

676
677
678
        // ensure pads availabe only when auto_pad is "NOT_SET"
        check_padding_mode(info, "CONV");

679
        if(contains(info.attributes, "strides"))
Paul's avatar
Paul committed
680
        {
681
682
683
            values["stride"].clear();
            copy(info.attributes["strides"].ints(), std::back_inserter(values["stride"]));
            check_attr_sizes(kdims, values["stride"].size(), "PARSE_CONV: inconsistent strides");
Paul's avatar
Paul committed
684
        }
685
        if(contains(info.attributes, "dilations"))
Paul's avatar
Paul committed
686
        {
687
688
689
690
            values["dilation"].clear();
            copy(info.attributes["dilations"].ints(), std::back_inserter(values["dilation"]));
            check_attr_sizes(
                kdims, values["dilation"].size(), "PARSE_CONV: inconsistent dilations");
Paul's avatar
Paul committed
691
        }
692
693
694
695

        std::vector<int64_t> padding;
        if(contains(info.attributes, "pads"))
        {
696
            values["padding"].clear();
697
698
699
700
            copy(info.attributes["pads"].ints(), std::back_inserter(padding));
            check_attr_sizes(kdims, padding.size() / 2, "PARSE_CONV: inconsistent paddings");
        }

701
        if(contains(info.attributes, "auto_pad"))
702
        {
703
704
            auto weight_lens = weights->get_shape().lens();
            std::vector<std::size_t> k_lens(weight_lens.begin() + 2, weight_lens.end());
705
706
707
708
709
710
            cal_auto_padding_size(info,
                                  values,
                                  k_lens,
                                  values["dilation"].to_vector<std::size_t>(),
                                  in_lens,
                                  padding);
Shucai Xiao's avatar
Shucai Xiao committed
711
712
713
714
715
            auto auto_pad = info.attributes["auto_pad"].s();
            if(auto_pad.find("SAME") != std::string::npos)
            {
                values["padding_mode"] = to_value(op::padding_mode_t::same);
            }
716
        }
717
        check_asym_padding(l0, padding, values);
718

719
        if(contains(info.attributes, "group"))
Khalique's avatar
Khalique committed
720
        {
721
            values["group"] = parse_value(info.attributes.at("group")).at<int>();
Khalique's avatar
Khalique committed
722
        }
kahmed10's avatar
kahmed10 committed
723

724
        recalc_conv_attributes(values, kdims);
725

726
        op.from_value(values);
kahmed10's avatar
kahmed10 committed
727
728
729
730
        auto l1 = prog.add_instruction(op, l0, args[1]);
        return add_bias(args, l1, 1);
    }

731
732
    instruction_ref
    parse_conv_transpose(const std::string&, node_info info, std::vector<instruction_ref> args)
kahmed10's avatar
kahmed10 committed
733
    {
734
735
736
        operation op = make_op("deconvolution");
        value values = op.to_value();
        // op::deconvolution op;
kahmed10's avatar
kahmed10 committed
737
738
        auto l0 = args[0];
        std::vector<std::int64_t> padding;
kahmed10's avatar
kahmed10 committed
739
740
741
742
743
        bool asym_padding = false;
        auto in_lens      = l0->get_shape().lens();
        assert(in_lens.size() > 2);
        auto kdims = in_lens.size() - 2;

744
745
746
        // ensure pads availabe only when auto_pad is "NOT_SET"
        check_padding_mode(info, "CONV_TRANSPOSE");

747
        if(contains(info.attributes, "pads"))
kahmed10's avatar
kahmed10 committed
748
        {
749
            copy(info.attributes["pads"].ints(), std::back_inserter(padding));
kahmed10's avatar
kahmed10 committed
750
751
752
753

            asym_padding = is_asym_padding(padding);

            if(not asym_padding)
kahmed10's avatar
kahmed10 committed
754
            {
kahmed10's avatar
kahmed10 committed
755
756
                size_t pad_ndims = padding.size() / 2;
                check_attr_sizes(kdims, pad_ndims, "PARSE_CONV_TRANSPOSE: inconsistent paddings");
757
                values["padding"].clear();
kahmed10's avatar
kahmed10 committed
758
759
                std::transform(padding.begin(),
                               padding.begin() + pad_ndims,
760
                               std::back_inserter(values["padding"]),
kahmed10's avatar
kahmed10 committed
761
                               [](auto pad_val) { return pad_val; });
kahmed10's avatar
kahmed10 committed
762
763
            }
        }
764
        if(contains(info.attributes, "strides"))
kahmed10's avatar
kahmed10 committed
765
        {
766
767
768
769
            values["stride"].clear();
            copy(info.attributes["strides"].ints(), std::back_inserter(values["stride"]));
            check_attr_sizes(
                kdims, values["stride"].size(), "PARSE_CONV_TRANSPOSE: inconsistent strides");
kahmed10's avatar
kahmed10 committed
770
        }
771
        if(contains(info.attributes, "dilations"))
Paul's avatar
Paul committed
772
        {
773
774
            values["dilation"].clear();
            copy(info.attributes["dilations"].ints(), std::back_inserter(values["dilation"]));
kahmed10's avatar
kahmed10 committed
775
            check_attr_sizes(
776
                kdims, values["dilation"].size(), "PARSE_CONV_TRANSPOSE: inconsistent dilations");
Paul's avatar
Paul committed
777
        }
778
        if(contains(info.attributes, "auto_pad"))
kahmed10's avatar
kahmed10 committed
779
        {
780
781
            auto s = info.attributes["auto_pad"].s();
            if(contains(info.attributes, "pads") and to_upper(s) != "NOTSET")
kahmed10's avatar
kahmed10 committed
782
            {
kahmed10's avatar
kahmed10 committed
783
784
                MIGRAPHX_THROW("PARSE_CONV_TRANSPOSE: auto_pad and padding cannot be specified "
                               "simultaneously");
kahmed10's avatar
kahmed10 committed
785
786
787
788
            }

            if(s.find("SAME") != std::string::npos)
            {
789
                values["padding_mode"] = to_value(op::padding_mode_t::same);
kahmed10's avatar
kahmed10 committed
790
791
792
            }
        }

793
        if(contains(info.attributes, "group"))
kahmed10's avatar
kahmed10 committed
794
        {
795
            values["group"] = parse_value(info.attributes.at("group")).at<int>();
kahmed10's avatar
kahmed10 committed
796
797
        }

798
        recalc_conv_attributes(values, kdims);
kahmed10's avatar
kahmed10 committed
799

800
        op.from_value(values);
kahmed10's avatar
kahmed10 committed
801
802
        auto l1                   = prog.add_instruction(op, l0, args[1]);
        std::vector<int64_t> dims = to_int64_vector(l1->get_shape().lens());
kahmed10's avatar
kahmed10 committed
803
804
        std::vector<int64_t> curr_shape(dims.begin() + 2, dims.end());
        if(asym_padding)
kahmed10's avatar
kahmed10 committed
805
        {
kahmed10's avatar
kahmed10 committed
806
807
808
809
810
811
812
813
814
815
816
817
            std::vector<int64_t> axes(kdims);
            std::iota(axes.begin(), axes.end(), 2); // ignore first 2 dims

            auto pad_kdim_start = padding.begin() + kdims;
            std::vector<int64_t> starts(padding.begin(), pad_kdim_start);

            std::vector<int64_t> ends{};
            std::transform(curr_shape.begin(),
                           curr_shape.end(),
                           pad_kdim_start,
                           std::back_inserter(ends),
                           [](auto curr_dim, auto pad_dim) { return curr_dim - pad_dim; });
kahmed10's avatar
kahmed10 committed
818

kahmed10's avatar
kahmed10 committed
819
            l1 = prog.add_instruction(op::slice{axes, starts, ends}, l1);
kahmed10's avatar
kahmed10 committed
820
821
        }

822
        if(contains(info.attributes, "output_padding"))
kahmed10's avatar
kahmed10 committed
823
        {
kahmed10's avatar
kahmed10 committed
824
825
            size_t non_kdims = dims.size() * 2 - kdims;
            std::vector<int64_t> output_padding(non_kdims, 0);
826
            copy(info.attributes["output_padding"].ints(), std::back_inserter(output_padding));
kahmed10's avatar
kahmed10 committed
827
828
829
830
            check_attr_sizes(kdims,
                             output_padding.size() - non_kdims,
                             "PARSE_CONV_TRANSPOSE: inconsistent output padding");
            l1 = prog.add_instruction(op::pad{output_padding}, l1);
kahmed10's avatar
kahmed10 committed
831
832
        }

833
        if(contains(info.attributes, "output_shape"))
kahmed10's avatar
kahmed10 committed
834
835
        {
            std::vector<int64_t> output_shape;
836
            copy(info.attributes["output_shape"].ints(), std::back_inserter(output_shape));
kahmed10's avatar
kahmed10 committed
837
838
839
840
            check_attr_sizes(
                kdims, output_shape.size(), "PARSE_CONV_TRANSPOSE: inconsistent output shape");
            dims = to_int64_vector(l1->get_shape().lens());
            copy(dims.begin() + 2, dims.end(), curr_shape.begin());
kahmed10's avatar
kahmed10 committed
841
842
            if(curr_shape != output_shape)
            {
kahmed10's avatar
kahmed10 committed
843
844
845
846
847
848
                std::vector<int64_t> target_padding(dims.size() * 2 - kdims, 0);
                std::transform(output_shape.begin(),
                               output_shape.end(),
                               curr_shape.begin(),
                               std::back_inserter(target_padding),
                               [](auto out_dim, auto curr_dim) { return out_dim - curr_dim; });
kahmed10's avatar
kahmed10 committed
849
850
851
852
853
                l1 = prog.add_instruction(op::pad{target_padding}, l1);
            }
        }

        return add_bias(args, l1, 1);
Paul's avatar
Paul committed
854
    }
Paul's avatar
Paul committed
855

856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
    static void
    tune_padding_to_symmetric(int64_t& left, int64_t& right, const int stride, int64_t& s_start)
    {
        s_start = 0;
        if(left > right)
        {
            right = left;
        }
        else if(left < right)
        {
            auto diff = right - left;
            s_start   = (diff + stride - 1) / stride;
            left      = left + s_start * stride;
            right     = left;
        }
    }

873
    static void tune_padding_size(const value& v,
874
875
876
877
878
                                  std::vector<int64_t>& padding,
                                  int count_include_pad,
                                  std::vector<int64_t>& s_start)
    {
        // maxpooling or count_include_pad is 1, no change is required.
879
        if(v.at("mode").to<std::string>() == "max" or count_include_pad == 1)
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
        {
            return;
        }

        // if padding is symmetric, return directly
        if(!is_asym_padding(padding))
        {
            return;
        }

        // asymmetric padding, make it symmetric
        std::size_t n_dims = padding.size() / 2;
        s_start.resize(n_dims);
        for(std::size_t i = 0; i < n_dims; ++i)
        {
895
896
            tune_padding_to_symmetric(
                padding[i], padding[i + n_dims], v.at("stride")[i].to<int64_t>(), s_start[i]);
897
898
899
        }
    }

900
901
    instruction_ref
    parse_pooling(const std::string& name, node_info info, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
902
    {
903
904
905
906
907
        std::string mode = ends_with(name, "MaxPool") ? "max" : "average";
        operation op     = make_op("pooling", {{"mode", mode}});
        value values     = op.to_value();
        auto l0          = args[0];
        auto in_lens     = l0->get_shape().lens();
908
909
910
        assert(in_lens.size() > 2);
        auto kdims = in_lens.size() - 2;

Khalique's avatar
Khalique committed
911
        if(starts_with(name, "Global"))
912
        {
913
            values["lengths"] = std::vector<size_t>(in_lens.begin() + 2, in_lens.end());
914
        }
915

916
917
        // does not support ceil_mode
        if(contains(info.attributes, "ceil_mode"))
Paul's avatar
Paul committed
918
        {
Shucai Xiao's avatar
Shucai Xiao committed
919
            values["ceil_mode"] = static_cast<bool>(info.attributes.at("ceil_mode").i());
920
        }
921

922
923
924
925
926
927
        // count include padding, if count include pad is 1, we always use
        // explicit pad
        int count_include_pad = 0;
        if(contains(info.attributes, "count_include_pad"))
        {
            count_include_pad = info.attributes.at("count_include_pad").i();
Paul's avatar
Paul committed
928
        }
929

930
        if(contains(info.attributes, "strides"))
Paul's avatar
Paul committed
931
        {
932
933
934
            values["stride"].clear();
            copy(info.attributes["strides"].ints(), std::back_inserter(values["stride"]));
            check_attr_sizes(kdims, values["stride"].size(), "PARSE_POOLING: inconsistent strides");
Paul's avatar
Paul committed
935
        }
936
        if(contains(info.attributes, "kernel_shape"))
Paul's avatar
Paul committed
937
        {
938
939
940
941
            values["lengths"].clear();
            copy(info.attributes["kernel_shape"].ints(), std::back_inserter(values["lengths"]));
            check_attr_sizes(
                kdims, values["lengths"].size(), "PARSE_POOLING: inconsistent lengths");
Paul's avatar
Paul committed
942
        }
943

944
945
946
947
        // ensure pads availabe only when auto_pad is "NOT_SET"
        check_padding_mode(info, "POOLING");

        std::vector<int64_t> paddings;
948
        float pad_val = ((mode == "max") ? std::numeric_limits<float>::lowest() : 0.0f);
949
950
        if(contains(info.attributes, "pads"))
        {
951
            values["padding"].clear();
952
953
954
955
956
            copy(info.attributes["pads"].ints(), std::back_inserter(paddings));
            check_attr_sizes(
                kdims, paddings.size() / 2, "PARSE_POOLING: inconsistent explicit paddings");
        }

957
        if(contains(info.attributes, "auto_pad"))
958
        {
959
            values["padding"].clear();
960
            // return paddings could be empty, then setting to 0 for no padding
961
962
963
964
965
966
            cal_auto_padding_size(info,
                                  values,
                                  values["lengths"].to_vector<std::size_t>(),
                                  {1, 1},
                                  in_lens,
                                  paddings);
967
        }
968

969
970
971
972
        if(paddings.size() != 2 * kdims)
        {
            paddings.resize(kdims * 2);
            std::fill_n(paddings.begin(), 2 * kdims, 0);
973
974
        }

975
        if(values["padding"].size() != kdims)
976
        {
977
978
            values["padding"].resize(kdims);
            std::fill_n(values["padding"].begin(), kdims, 0);
979
        }
980

981
        if(values["stride"].size() != kdims)
982
        {
983
984
            values["stride"].resize(kdims);
            std::fill_n(values["stride"].begin(), kdims, 1);
985
        }
986
987
988
989
990
        // used to calculate the supposed output shape
        std::vector<int64_t> orig_padding(paddings.begin(), paddings.end());

        std::vector<int64_t> slice_start;
        std::vector<int64_t> slice_end;
991
        tune_padding_size(values, paddings, count_include_pad, slice_start);
992
993
994
995
996
997
998
999

        if(!slice_start.empty())
        {
            // calculate expected output shape
            orig_padding.insert(orig_padding.begin() + kdims, 2, 0);
            orig_padding.insert(orig_padding.begin(), 2, 0);
            op::pad pad{orig_padding, 0.0f};
            shape padded_shape = pad.compute_shape({l0->get_shape()});
1000
            auto out_lens      = make_op("pooling", values).compute_shape({padded_shape}).lens();
1001

1002
1003
1004
1005
1006
1007
1008
1009
1010
            // compute slice_end information
            slice_end.resize(slice_start.size());
            std::transform(out_lens.begin() + 2,
                           out_lens.end(),
                           slice_start.begin(),
                           slice_end.begin(),
                           [](auto i, auto j) { return i + j; });
        }

1011
        check_asym_padding(l0, paddings, values, count_include_pad, pad_val);
1012
        in_lens = l0->get_shape().lens();
1013
1014
        for(size_t i = 0; i < kdims; i++)
        {
1015
1016
            if(values["lengths"][i].to<int64_t>() >
               in_lens[i + 2] + 2 * values["padding"][i].to<int64_t>())
1017
            {
1018
                MIGRAPHX_THROW("PARSE_POOLING: kernel shape is too large");
1019
1020
            }
        }
1021
        op.from_value(values);
1022
1023
1024
1025
1026
1027
        auto l1 = prog.add_instruction(op, l0);
        if(!slice_start.empty())
        {
            std::vector<int64_t> axes(kdims);
            std::iota(axes.begin(), axes.end(), 2);
            l1 = prog.add_instruction(op::slice{axes, slice_start, slice_end}, l1);
1028
1029
        }

1030
        return l1;
Paul's avatar
Paul committed
1031
1032
    }

Paul's avatar
Paul committed
1033
    instruction_ref
1034
    parse_reshape(const std::string&, node_info info, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
1035
    {
1036
        op::reshape op;
Paul's avatar
Paul committed
1037
1038
        if(args.size() == 1)
        {
1039
            literal s = parse_value(info.attributes.at("shape"));
1040
            s.visit([&](auto v) { copy(v, std::back_inserter(op.dims)); });
Paul's avatar
Paul committed
1041
1042
1043
        }
        if(args.size() == 2)
        {
Paul's avatar
Paul committed
1044
            auto s = args[1]->eval();
Shucai Xiao's avatar
Shucai Xiao committed
1045
            check_arg_empty(s, "Reshape: dynamic shape is not supported");
Paul's avatar
Paul committed
1046
            s.visit([&](auto v) { copy(v, std::back_inserter(op.dims)); });
Paul's avatar
Paul committed
1047
        }
1048

Shucai Xiao's avatar
Shucai Xiao committed
1049
        return prog.add_instruction(op, make_contiguous(args[0]));
Paul's avatar
Paul committed
1050
1051
    }

Shucai Xiao's avatar
Shucai Xiao committed
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
    instruction_ref
    parse_gather_elements(const std::string&, node_info info, std::vector<instruction_ref> args)
    {
        int axis = 0;
        if(contains(info.attributes, "axis"))
        {
            axis = parse_value(info.attributes.at("axis")).at<int>();
        }

        // standardize input data and index
        auto arg_data = make_contiguous(args[0]);
        auto arg_ind  = make_contiguous(args[1]);

        auto data_s = arg_data->get_shape();
        auto ind_s  = arg_ind->get_shape();

        if(data_s.lens().size() != ind_s.lens().size())
        {
            MIGRAPHX_THROW("PARSE_GATHER_ELEMENTS: input data and index must have the same rank!");
        }

        int n_rank     = static_cast<int>(data_s.lens().size());
        int tuned_axis = (axis < 0) ? (axis + n_rank) : axis;

        auto axis_stride      = data_s.strides()[tuned_axis];
        int64_t data_elem_num = static_cast<int64_t>(data_s.elements());
        // reshape the input data as one dimension and used as input data
        // to the gather operator
        arg_data = prog.add_instruction(op::reshape{{data_elem_num}}, arg_data);

        std::size_t elem_num = ind_s.elements();
        std::vector<int> ind_index(elem_num);
        std::iota(ind_index.begin(), ind_index.end(), 0);

        // convert index in input indices to that in input data
        std::vector<int> data_indices(elem_num);
        std::transform(ind_index.begin(), ind_index.end(), data_indices.begin(), [&](auto i) {
            return data_s.index(ind_s.multi(i));
        });

        std::vector<int> vec_axis_ind(elem_num);
        std::transform(ind_index.begin(), ind_index.end(), vec_axis_ind.begin(), [&](auto i) {
            return ind_s.multi(i)[tuned_axis];
        });

        auto l_shape_idx =
            prog.add_literal(literal(ind_s, data_indices.begin(), data_indices.end()));
        auto l_dim_idx = prog.add_literal(literal(ind_s, vec_axis_ind.begin(), vec_axis_ind.end()));
        auto l_stride  = prog.add_literal(literal{{ind_s.type(), {1}}, {axis_stride}});
        l_stride       = prog.add_instruction(op::multibroadcast{ind_s.lens()}, l_stride);
1102
1103
1104
        auto dim_diff  = prog.add_instruction(make_op("sub"), arg_ind, l_dim_idx);
        auto delta     = prog.add_instruction(make_op("mul"), dim_diff, l_stride);
        auto ind       = prog.add_instruction(make_op("add"), l_shape_idx, delta);
Shucai Xiao's avatar
Shucai Xiao committed
1105
1106
1107
1108
1109

        op::gather op{0};
        return prog.add_instruction(op, arg_data, ind);
    }

1110
    instruction_ref
1111
    parse_slice(const std::string&, node_info info, std::vector<instruction_ref> args)
1112
1113
    {
        op::slice op;
Shucai Xiao's avatar
Shucai Xiao committed
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135

        // slice can have up to 5 inputs, we first check the 5th one
        // to decide whether MIGRAPHX can handle this slice
        if(args.size() == 5)
        {
            migraphx::argument step_arg = args.back()->eval();
            check_arg_empty(step_arg, "PARSE_SLICE: cannot handle variable steps for slice");
            std::vector<int> steps;
            step_arg.visit([&](auto s) { steps.assign(s.begin(), s.end()); });
            if(!std::all_of(steps.begin(), steps.end(), [](auto s) { return s == 1; }))
            {
                MIGRAPHX_THROW("PARSE_SLICE: cannot handle step other than 1");
            }
        }

        if(args.size() >= 4)
        {
            migraphx::argument axes_arg = args.at(3)->eval();
            check_arg_empty(axes_arg, "PARSE_SLICE: cannot handle variable axes for slice");
            axes_arg.visit([&](auto s) { op.axes.assign(s.begin(), s.end()); });
        }
        else if(contains(info.attributes, "axes"))
1136
        {
1137
            literal s = parse_value(info.attributes.at("axes"));
1138
1139
            s.visit([&](auto v) { copy(v, std::back_inserter(op.axes)); });
        }
Shucai Xiao's avatar
Shucai Xiao committed
1140
1141

        if(args.size() >= 3)
Khalique's avatar
Khalique committed
1142
        {
Shucai Xiao's avatar
Shucai Xiao committed
1143
1144
1145
            migraphx::argument end_arg = args.at(2)->eval();
            check_arg_empty(end_arg, "PARSE_SLICE: cannot handle variable ends for slice");
            end_arg.visit([&](auto s) { op.ends.assign(s.begin(), s.end()); });
Khalique's avatar
Khalique committed
1146
        }
Shucai Xiao's avatar
Shucai Xiao committed
1147
        else if(contains(info.attributes, "ends"))
1148
        {
1149
1150
            literal s = parse_value(info.attributes.at("ends"));
            s.visit([&](auto v) { copy(v, std::back_inserter(op.ends)); });
1151
        }
Shucai Xiao's avatar
Shucai Xiao committed
1152
1153
1154
1155
1156
1157
1158
1159

        if(args.size() >= 2)
        {
            migraphx::argument start_arg = args.at(1)->eval();
            check_arg_empty(start_arg, "PARSE_SLICE: cannot handle variable starts for slice");
            start_arg.visit([&](auto s) { op.starts.assign(s.begin(), s.end()); });
        }
        else if(contains(info.attributes, "starts"))
1160
        {
1161
            literal s = parse_value(info.attributes.at("starts"));
1162
1163
            s.visit([&](auto v) { copy(v, std::back_inserter(op.starts)); });
        }
Shucai Xiao's avatar
Shucai Xiao committed
1164

kahmed10's avatar
kahmed10 committed
1165
1166
1167
1168
1169
1170
1171
        if(op.axes.empty())
        {
            std::vector<int64_t> axes(args[0]->get_shape().lens().size());
            std::iota(axes.begin(), axes.end(), int64_t{0});
            op.axes = axes;
        }

1172
1173
1174
        return prog.add_instruction(op, args[0]);
    }

1175
1176
    instruction_ref
    parse_constant(const std::string&, node_info info, const std::vector<instruction_ref>&)
Paul's avatar
Paul committed
1177
    {
1178
        literal v = parse_value(info.attributes.at("value"));
1179
        // return empty literal
Shucai Xiao's avatar
Shucai Xiao committed
1180
        if(v.get_shape().elements() == 0)
1181
1182
1183
1184
        {
            return prog.add_literal(literal{});
        }

1185
        auto dim_size = info.attributes.at("value").t().dims_size();
1186
1187
        // if dim_size is 0, it is a scalar
        if(dim_size == 0)
1188
        {
1189
            migraphx::shape scalar_shape{v.get_shape().type()};
1190
1191
1192
            return prog.add_literal(migraphx::literal{scalar_shape, v.data()});
        }

Paul's avatar
Paul committed
1193
1194
        return prog.add_literal(v);
    }
Paul's avatar
Paul committed
1195

Paul's avatar
Paul committed
1196
    instruction_ref
1197
    parse_gemm(const std::string&, node_info info, std::vector<instruction_ref> args)
Paul's avatar
Paul committed
1198
1199
    {
        float alpha = 1.0f;
Khalique's avatar
Khalique committed
1200
        float beta  = 1.0f;
Paul's avatar
Paul committed
1201
1202
        bool transa = false;
        bool transb = false;
1203
        if(contains(info.attributes, "alpha"))
Paul's avatar
Paul committed
1204
        {
1205
            alpha = parse_value(info.attributes.at("alpha")).at<float>();
Paul's avatar
Paul committed
1206
        }
1207
        if(contains(info.attributes, "beta"))
Paul's avatar
Paul committed
1208
        {
1209
            beta = parse_value(info.attributes.at("beta")).at<float>();
Paul's avatar
Paul committed
1210
        }
1211
        if(contains(info.attributes, "transA"))
Paul's avatar
Paul committed
1212
        {
1213
            transa = parse_value(info.attributes.at("transA")).at<bool>();
Paul's avatar
Paul committed
1214
        }
1215
        if(contains(info.attributes, "transB"))
Paul's avatar
Paul committed
1216
        {
1217
            transb = parse_value(info.attributes.at("transB")).at<bool>();
Paul's avatar
Paul committed
1218
        }
1219
1220
1221
1222
1223
1224

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

1225
1226
        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
1227
1228
        if(args.size() == 3)
        {
1229
            if(beta != 0.f && args[2]->get_shape().elements() > 0)
1230
            {
Shucai Xiao's avatar
Shucai Xiao committed
1231
                auto out_lens   = l1->get_shape().lens();
1232
                out_lens.back() = l2->get_shape().lens().back();
Shucai Xiao's avatar
Shucai Xiao committed
1233
                auto l3         = args[2];
Shucai Xiao's avatar
Shucai Xiao committed
1234
1235
                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
1236
                {
1237
                    l3 = prog.add_instruction(op::multibroadcast{out_lens}, args[2]);
Khalique's avatar
Khalique committed
1238
                }
1239
1240
                return prog.add_instruction(
                    make_op("dot", {{"alpha", alpha}, {"beta", beta}}), l1, l2, l3);
1241
            }
Paul's avatar
Paul committed
1242
        }
1243

1244
        return prog.add_instruction(make_op("dot", {{"alpha", alpha}, {"beta", beta}}), l1, l2);
Paul's avatar
Paul committed
1245
1246
    }

1247
1248
1249
1250
    instruction_ref parse_matmul(const std::string&,
                                 const std::string& op_name,
                                 const node_info&,
                                 std::vector<instruction_ref> args)
1251
    {
Shucai Xiao's avatar
Shucai Xiao committed
1252
1253
        auto l0      = args[0];
        auto l1      = args[1];
1254
1255
1256
1257
1258
        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
1259
        if(l0_lens.size() == 1)
1260
1261
1262
1263
1264
1265
1266
        {
            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
1267
        if(l1_lens.size() == 1)
1268
1269
1270
1271
1272
1273
1274
1275
        {
            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
1276
        if(!std::equal(l0_lens.rbegin() + 2, l0_lens.rend(), l1_lens.rbegin() + 2, l1_lens.rend()))
1277
1278
1279
1280
1281
1282
        {
            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);
1283
            l0_broadcasted_lens = output_lens;
1284
            l0_broadcasted_lens.insert(l0_broadcasted_lens.end(), l0_it, l0_lens.end());
1285
            l1_broadcasted_lens = output_lens;
1286
            l1_broadcasted_lens.insert(l1_broadcasted_lens.end(), l1_it, l1_lens.end());
Shucai Xiao's avatar
Shucai Xiao committed
1287
            if(l0_lens != l0_broadcasted_lens)
1288
1289
1290
            {
                bl0 = prog.add_instruction(op::multibroadcast{l0_broadcasted_lens}, l0);
            }
Shucai Xiao's avatar
Shucai Xiao committed
1291
            if(l1_lens != l1_broadcasted_lens)
1292
1293
1294
1295
1296
            {
                bl1 = prog.add_instruction(op::multibroadcast{l1_broadcasted_lens}, l1);
            }
        }

1297
1298
        auto dot_res =
            prog.add_instruction(make_op(op_name, {{"alpha", 1}, {"beta", 0}}), bl0, bl1);
1299
        int64_t num_axis = static_cast<int64_t>(dot_res->get_shape().lens().size());
Shucai Xiao's avatar
Shucai Xiao committed
1300
        if(is_a_prepended)
1301
1302
1303
1304
        {
            dot_res = prog.add_instruction(op::squeeze{{num_axis - 2}}, dot_res);
            --num_axis;
        }
Shucai Xiao's avatar
Shucai Xiao committed
1305
        if(is_b_appended)
1306
1307
1308
        {
            dot_res = prog.add_instruction(op::squeeze{{num_axis - 1}}, dot_res);
        }
Shucai Xiao's avatar
Shucai Xiao committed
1309

1310
1311
1312
        return dot_res;
    }

1313
    instruction_ref
1314
    parse_batchnorm(const std::string&, node_info info, std::vector<instruction_ref> args)
1315
    {
Scott Thornton's avatar
Scott Thornton committed
1316
1317
        float epsilon                                     = 1e-5f;
        float momentum                                    = 0.9f;
1318
        op::batch_norm_inference::bn_infer_mode_t bn_mode = op::batch_norm_inference::spatial;
1319
        if(contains(info.attributes, "epsilon"))
1320
        {
1321
            epsilon = parse_value(info.attributes.at("epsilon")).at<float>();
1322
        }
1323
        if(contains(info.attributes, "momentum"))
1324
        {
1325
            momentum = parse_value(info.attributes.at("momentum")).at<float>();
1326
        }
1327
        if(contains(info.attributes, "spatial"))
1328
        {
1329
            bn_mode = (parse_value(info.attributes.at("spatial")).at<uint64_t>() > 0)
1330
1331
                          ? op::batch_norm_inference::spatial
                          : op::batch_norm_inference::per_activation;
1332
        }
Paul's avatar
Paul committed
1333
        op::batch_norm_inference op{epsilon, momentum, bn_mode};
Paul's avatar
Paul committed
1334
        return prog.add_instruction(op, std::move(args));
1335
1336
    }

1337
1338
    instruction_ref
    parse_instancenorm(const std::string&, node_info info, std::vector<instruction_ref> args)
kahmed10's avatar
kahmed10 committed
1339
1340
1341
1342
1343
1344
    {
        // y = scale * ( x - mean ) / sqrt ( variance + epsilon ) + bias
        // mean = reduce_mean({H, W}, x)
        // variance = reduce_mean({H, W}, (x - mean)^2)

        float epsilon = 1e-5f;
1345
        if(contains(info.attributes, "epsilon"))
kahmed10's avatar
kahmed10 committed
1346
        {
1347
            epsilon = parse_value(info.attributes.at("epsilon")).at<float>();
kahmed10's avatar
kahmed10 committed
1348
1349
1350
1351
1352
1353
        }
        auto x     = args[0];
        auto scale = args[1];
        auto bias  = args[2];
        auto dims  = x->get_shape().lens();

1354
        auto mean            = prog.add_instruction(make_op("reduce_mean", {{"axes", {2, 3}}}), x);
kahmed10's avatar
kahmed10 committed
1355
        auto mean_bcast      = prog.add_instruction(op::multibroadcast{dims}, mean);
1356
1357
1358
        auto l0              = prog.add_instruction(make_op("sqdiff"), x, mean_bcast);
        auto variance        = prog.add_instruction(make_op("reduce_mean", {{"axes", {2, 3}}}), l0);
        auto l1              = prog.add_instruction(make_op("sub"), x, mean_bcast);
kahmed10's avatar
kahmed10 committed
1359
1360
1361
        auto epsilon_literal = prog.add_literal(epsilon);
        auto epsilon_bcast   = prog.add_instruction(op::multibroadcast{dims}, epsilon_literal);
        auto variance_bcast  = prog.add_instruction(op::multibroadcast{dims}, variance);
1362
1363
1364
        auto l2              = prog.add_instruction(make_op("add"), variance_bcast, epsilon_bcast);
        auto l3              = prog.add_instruction(make_op("rsqrt"), l2);
        auto l4              = prog.add_instruction(make_op("mul"), l1, l3);
kahmed10's avatar
kahmed10 committed
1365
1366
1367
        auto scale_bcast     = prog.add_instruction(op::broadcast{1, dims}, scale);
        ;
        auto bias_bcast = prog.add_instruction(op::broadcast{1, dims}, bias);
1368
1369
        auto l5         = prog.add_instruction(make_op("mul"), l4, scale_bcast);
        return prog.add_instruction(make_op("add"), l5, bias_bcast);
kahmed10's avatar
kahmed10 committed
1370
1371
    }

1372
1373
    instruction_ref
    parse_leaky_relu(const std::string&, node_info info, std::vector<instruction_ref> args)
1374
    {
Khalique's avatar
Khalique committed
1375
        float alpha = 0.01; // default alpha val for leaky relu
1376
        if(contains(info.attributes, "alpha"))
1377
        {
1378
            alpha = parse_value(info.attributes.at("alpha")).at<float>();
1379
        }
1380
        auto op = make_op("leaky_relu", {{"alpha", alpha}});
1381
1382
1383
        return prog.add_instruction(op, args.front());
    }

1384
    instruction_ref parse_elu(const std::string&, node_info info, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
1385
1386
    {
        float alpha = 1.0; // default alpha val for elu
1387
        if(contains(info.attributes, "alpha"))
Khalique's avatar
Khalique committed
1388
        {
1389
            alpha = parse_value(info.attributes.at("alpha")).at<float>();
Khalique's avatar
Khalique committed
1390
        }
1391
        auto op = make_op("elu", {{"alpha", alpha}});
Khalique's avatar
Khalique committed
1392
1393
1394
        return prog.add_instruction(op, args.front());
    }

1395
    instruction_ref parse_lrn(const std::string&, node_info info, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
1396
1397
    {
        float alpha = 0.0001;
Khalique's avatar
Khalique committed
1398
1399
1400
        float beta  = 0.75;
        float bias  = 1.0;
        int size    = 1;
1401
1402
1403
1404
1405
1406
1407
1408
        if(contains(info.attributes, "alpha"))
            alpha = parse_value(info.attributes.at("alpha")).at<float>();
        if(contains(info.attributes, "beta"))
            beta = parse_value(info.attributes.at("beta")).at<float>();
        if(contains(info.attributes, "bias"))
            bias = parse_value(info.attributes.at("bias")).at<float>();
        if(contains(info.attributes, "size"))
            size = parse_value(info.attributes.at("size")).at<int>();
Khalique's avatar
Khalique committed
1409
1410
1411
1412
        op::lrn op{alpha, beta, bias, size};
        return prog.add_instruction(op, args.front());
    }

1413
1414
    instruction_ref
    parse_imagescaler(const std::string&, node_info info, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
1415
1416
1417
    {
        float scale = 1.0;
        std::vector<float> bias{};
1418
        if(contains(info.attributes, "scale"))
Khalique's avatar
Khalique committed
1419
        {
1420
            scale = parse_value(info.attributes.at("scale")).at<float>();
Khalique's avatar
Khalique committed
1421
1422
        }

1423
        if(contains(info.attributes, "bias"))
Khalique's avatar
Khalique committed
1424
        {
1425
            auto&& bias_floats = info.attributes["bias"].floats();
Khalique's avatar
Khalique committed
1426
1427
            bias               = std::vector<float>(bias_floats.begin(), bias_floats.end());
        }
Shucai Xiao's avatar
Shucai Xiao committed
1428
1429
1430
        auto input_shape       = args.front()->get_shape();
        auto const& input_lens = input_shape.lens();
        auto input_type        = input_shape.type();
Khalique's avatar
Khalique committed
1431

Shucai Xiao's avatar
Shucai Xiao committed
1432
1433
        auto scale_val = prog.add_literal(literal{shape{input_type}, {scale}});
        auto bias_vals = prog.add_literal(literal{shape{input_type, {bias.size()}}, bias});
Khalique's avatar
Khalique committed
1434

1435
        auto scale_tensor = prog.add_instruction(migraphx::op::scalar{input_lens}, scale_val);
1436
1437
1438
1439
        auto img_scaled =
            prog.add_instruction(migraphx::make_op("mul"), args.front(), scale_tensor);
        auto bias_bcast = prog.add_instruction(migraphx::op::broadcast{1, input_lens}, bias_vals);
        return prog.add_instruction(migraphx::make_op("add"), img_scaled, bias_bcast);
Khalique's avatar
Khalique committed
1440
    }
Khalique's avatar
Khalique committed
1441

Khalique's avatar
Khalique committed
1442
    instruction_ref
1443
    parse_transpose(const std::string&, node_info info, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
1444
1445
    {
        std::vector<int64_t> perm{};
1446
        if(contains(info.attributes, "perm"))
Khalique's avatar
Khalique committed
1447
        {
1448
            auto&& perm_vals = info.attributes["perm"].ints();
Khalique's avatar
Khalique committed
1449
1450
            perm             = std::vector<int64_t>(perm_vals.begin(), perm_vals.end());
        }
Paul's avatar
Paul committed
1451
        return prog.add_instruction(migraphx::op::transpose{perm}, args.front());
Khalique's avatar
Khalique committed
1452
1453
    }

1454
    instruction_ref parse_pad(const std::string&, node_info info, std::vector<instruction_ref> args)
Khalique's avatar
Khalique committed
1455
1456
    {
        std::vector<int64_t> pads{};
1457
1458
1459
1460
1461
1462
1463
        if(args.size() >= 2)
        {
            auto pad_arg = args.at(1)->eval();
            check_arg_empty(pad_arg, "PARSE_PAD: pad input must be constant");
            pad_arg.visit([&](auto v) { pads.assign(v.begin(), v.end()); });
        }
        else if(contains(info.attributes, "pads"))
Khalique's avatar
Khalique committed
1464
        {
1465
            auto&& pad_vals = info.attributes["pads"].ints();
Khalique's avatar
Khalique committed
1466
1467
            pads            = std::vector<int64_t>(pad_vals.begin(), pad_vals.end());
        }
1468
1469
1470
1471
1472
        else
        {
            MIGRAPHX_THROW("PARSE_PAD: pad must be available");
        }

1473
        // check if padding is actually being done (at least one value is nonzero)
Khalique's avatar
Khalique committed
1474
        if(std::all_of(pads.begin(), pads.end(), [](const int& i) { return i == 0; }))
1475
        {
1476
            return prog.add_instruction(make_op("identity"), args.front());
1477
        }
1478

kahmed10's avatar
kahmed10 committed
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
        if(contains(info.attributes, "mode"))
        {
            auto mode = info.attributes.at("mode").s();
            if(mode == "reflect")
                return reflect_pad(pads, args.front());
            if(mode != "constant")
            {
                MIGRAPHX_THROW(
                    "PARSE_PAD: migraphx currently only supports constant and reflect padding");
            }
        }

1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
        float value = 0.0f;
        // third input is the value
        if(args.size() == 3)
        {
            auto val_ins = args.at(2);
            if(!val_ins->can_eval())
            {
                MIGRAPHX_THROW("PARSE_PAD: input value must be constant");
            }
            auto val_arg = val_ins->eval();
            if(val_arg.get_shape().elements() != 1)
            {
                MIGRAPHX_THROW("PARSE_PAD: value should contain only one element");
            }
            value = val_arg.at<float>();
        }
        else if(contains(info.attributes, "value"))
Khalique's avatar
Khalique committed
1508
        {
1509
            value = parse_value(info.attributes.at("value")).at<float>();
Khalique's avatar
Khalique committed
1510
        }
1511

Khalique's avatar
Khalique committed
1512
1513
        return prog.add_instruction(migraphx::op::pad{pads, value}, args.front());
    }
1514
1515
1516
    // Use a literal instruction to replace the shape since, output of
    // shape operator are literals in migraphx
    instruction_ref
1517
    parse_shape(const std::string&, const node_info&, std::vector<instruction_ref> args)
1518
1519
    {
        if(args.size() != 1)
1520
            MIGRAPHX_THROW("Shape: operator should have 1 operand");
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
        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
1533
1534
    instruction_ref
    parse_constant_fill(const std::string&, node_info info, std::vector<instruction_ref> args)
1535
1536
1537
1538
1539
    {
        int input_as_shape = 0;
        int dtype          = 1;
        float value        = 0.0f;

1540
        if(contains(info.attributes, "dtype"))
1541
        {
1542
            dtype = parse_value(info.attributes.at("dtype")).at<int>();
1543
        }
Shucai Xiao's avatar
Shucai Xiao committed
1544
        shape::type_t type = get_type(dtype);
1545

1546
        if(contains(info.attributes, "input_as_shape"))
1547
        {
1548
            input_as_shape = parse_value(info.attributes.at("input_as_shape")).at<int>();
1549
1550
        }

1551
        if(contains(info.attributes, "value"))
1552
        {
1553
            value = parse_value(info.attributes.at("value")).at<float>();
1554
1555
        }

1556
        if(contains(info.attributes, "extra_shape"))
Shucai Xiao's avatar
Shucai Xiao committed
1557
        {
1558
            MIGRAPHX_THROW("ConstantFill: cannot handle extra shape attribute");
1559
1560
        }

1561
1562
        if(input_as_shape == 1)
        {
Shucai Xiao's avatar
Shucai Xiao committed
1563
            if(args.size() != 1)
1564
            {
1565
                MIGRAPHX_THROW("ConstantFill: need an input argument as output shape");
1566
1567
            }

1568
            if(contains(info.attributes, "shape"))
Shucai Xiao's avatar
Shucai Xiao committed
1569
            {
1570
                MIGRAPHX_THROW("ConstantFill: cannot set the shape argument and pass in an input "
Shucai Xiao's avatar
Shucai Xiao committed
1571
                               "at the same time");
1572
1573
            }

1574
            migraphx::argument in = args[0]->eval();
Shucai Xiao's avatar
Shucai Xiao committed
1575
            check_arg_empty(in, "ConstantFill: dynamic shape is not supported");
1576

1577
1578
1579
            std::vector<std::size_t> dims;
            in.visit([&](auto input) { dims.assign(input.begin(), input.end()); });
            migraphx::shape s(type, dims);
1580
1581
            std::vector<float> values(s.elements(), value);
            return prog.add_literal(migraphx::literal(s, values));
1582
1583
1584
        }
        else if(input_as_shape == 0)
        {
1585
            if(!contains(info.attributes, "shape"))
Shucai Xiao's avatar
Shucai Xiao committed
1586
            {
1587
                MIGRAPHX_THROW("ConstantFill: attribute output shape is needed");
1588
1589
            }

1590
            literal ls = parse_value(info.attributes.at("shape"));
1591
            std::vector<std::size_t> dims;
Shucai Xiao's avatar
Shucai Xiao committed
1592
            ls.visit([&](auto s) { dims.assign(s.begin(), s.end()); });
1593
            migraphx::shape s{type, dims};
1594
1595
            std::vector<float> values(s.elements(), value);
            return prog.add_literal(migraphx::literal(s, values));
1596
1597
1598
        }
        else
        {
1599
            MIGRAPHX_THROW("ConstantFill: wrong value of attribute input_as_shape");
1600
1601
1602
        }
    }

1603
1604
    instruction_ref
    parse_constant_of_shape(const std::string&, node_info info, std::vector<instruction_ref> args)
1605
1606
    {
        literal l_val{};
1607
        if(contains(info.attributes, "value"))
1608
        {
1609
            l_val = parse_value(info.attributes.at("value"));
Shucai Xiao's avatar
Shucai Xiao committed
1610
            if(l_val.get_shape().elements() != 1)
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
            {
                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();
1622

Shucai Xiao's avatar
Shucai Xiao committed
1623
        if(args.empty())
1624
        {
Shucai Xiao's avatar
Shucai Xiao committed
1625
            MIGRAPHX_THROW("ConstantOfShape : must have 1 input!");
1626
1627
1628
        }
        else
        {
1629
1630
            migraphx::shape s;
            // empty input tensor, output is a scalar
Shucai Xiao's avatar
Shucai Xiao committed
1631
            if(args[0]->get_shape().elements() == 0)
1632
            {
1633
                s = migraphx::shape{type, {1}, {0}};
1634
            }
1635
1636
1637
            else
            {
                migraphx::argument in = args[0]->eval();
Shucai Xiao's avatar
Shucai Xiao committed
1638
                check_arg_empty(in, "ConstantOfShape: dynamic shape is not supported");
1639

1640
1641
1642
1643
                std::vector<std::size_t> dims;
                in.visit([&](auto input) { dims.assign(input.begin(), input.end()); });
                s = migraphx::shape{type, dims};
            }
1644

Shucai Xiao's avatar
Shucai Xiao committed
1645
            literal l_out{};
1646
            l_val.visit([&](auto val) {
Shucai Xiao's avatar
Shucai Xiao committed
1647
                using val_type = std::remove_cv_t<typename decltype(val)::value_type>;
1648
                // l_val contains only one element
1649
                std::vector<val_type> out_vec(s.elements(), val.front());
1650
1651
1652
1653
1654
1655
1656
                l_out = literal(s, out_vec);
            });

            return prog.add_literal(l_out);
        }
    }

Shucai Xiao's avatar
Shucai Xiao committed
1657
    instruction_ref
1658
    parse_expand(const std::string&, const node_info&, std::vector<instruction_ref> args)
1659
    {
Shucai Xiao's avatar
Shucai Xiao committed
1660
        auto in_lens             = args[0]->get_shape().lens();
1661
        migraphx::argument arg_s = args[1]->eval();
Shucai Xiao's avatar
Shucai Xiao committed
1662
        check_arg_empty(arg_s, "Expand: dynamic shape is not supported");
1663
1664
1665
        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
1666
        return prog.add_instruction(op::multibroadcast{out_lens}, args[0]);
1667
1668
    }

Shucai Xiao's avatar
Shucai Xiao committed
1669
    std::vector<instruction_ref>
1670
    parse_rnn(const std::string&, node_info info, std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
1671
1672
    {
        migraphx::shape input_shape = args[0]->get_shape();
1673
        std::size_t hidden_size     = args[1]->get_shape().lens()[1];
Shucai Xiao's avatar
Shucai Xiao committed
1674

1675
        if(contains(info.attributes, "hidden_size"))
Shucai Xiao's avatar
Shucai Xiao committed
1676
        {
1677
            std::size_t hidden_size_att = parse_value(info.attributes.at("hidden_size")).at<int>();
Shucai Xiao's avatar
Shucai Xiao committed
1678
            if(hidden_size != hidden_size_att)
Shucai Xiao's avatar
Shucai Xiao committed
1679
1680
1681
            {
                MIGRAPHX_THROW("RNN: hidden size mismatch in input and attribute");
            }
Shucai Xiao's avatar
Shucai Xiao committed
1682
1683
1684
1685
        }

        // Handling of direction to be added later
        std::string direction{"forward"};
1686
        if(contains(info.attributes, "direction"))
Shucai Xiao's avatar
Shucai Xiao committed
1687
        {
1688
            direction = info.attributes.at("direction").s();
Shucai Xiao's avatar
Shucai Xiao committed
1689
1690
        }

1691
        op::rnn_direction dirct = op::rnn_direction::forward;
Shucai Xiao's avatar
Shucai Xiao committed
1692
1693
        if(direction == "bidirectional")
        {
1694
            dirct = op::rnn_direction::bidirectional;
Shucai Xiao's avatar
Shucai Xiao committed
1695
1696
1697
        }
        else if(direction == "reverse")
        {
1698
            dirct = op::rnn_direction::reverse;
Shucai Xiao's avatar
Shucai Xiao committed
1699
1700
        }

1701
        std::vector<std::string> vec_names{"tanh"};
1702
        if(contains(info.attributes, "activations"))
1703
        {
1704
            auto names = info.attributes.at("activations").strings();
1705
            vec_names.clear();
1706
            vec_names.resize(names.size());
Shucai Xiao's avatar
Shucai Xiao committed
1707
1708
1709
            std::transform(names.begin(), names.end(), vec_names.begin(), [](auto name) {
                return to_lower(name);
            });
1710
1711
        }

1712
1713
1714
        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
1715
        if(name_it != vec_names.end())
1716
1717
1718
        {
            MIGRAPHX_THROW("RNN: activation function " + std::string(*name_it) + " not supported");
        }
1719

Shucai Xiao's avatar
Shucai Xiao committed
1720
        // bidirectional case should have two activation functions.
Shucai Xiao's avatar
Shucai Xiao committed
1721
        // one is for forward, and the other is for reverse.
Shucai Xiao's avatar
Shucai Xiao committed
1722
        // if only one actv function is provided, we use it in both
1723
        // forward and reverse direction
1724
        if(dirct == op::rnn_direction::bidirectional)
1725
        {
Shucai Xiao's avatar
Shucai Xiao committed
1726
            if(vec_names.size() == 1)
1727
1728
1729
1730
1731
            {
                vec_names.push_back(vec_names.at(0));
            }
        }

Shucai Xiao's avatar
Shucai Xiao committed
1732
        std::vector<operation> vec_actv_funcs(vec_names.size());
Paul's avatar
Paul committed
1733
1734
1735
1736
        std::transform(vec_names.begin(),
                       vec_names.end(),
                       vec_actv_funcs.begin(),
                       [&](const auto& fn) { return map_actv_funcs[fn]; });
Shucai Xiao's avatar
Shucai Xiao committed
1737

Shucai Xiao's avatar
Shucai Xiao committed
1738
1739
        // To be added later
        float clip = 0.0;
1740
        if(contains(info.attributes, "clip"))
Shucai Xiao's avatar
Shucai Xiao committed
1741
        {
1742
            clip = parse_value(info.attributes.at("clip")).at<float>();
Shucai Xiao's avatar
Shucai Xiao committed
1743
1744
        }

1745
1746
        // if the number of arguments is less than 6, append
        // undefined operator to have 6 arguments
Shucai Xiao's avatar
Shucai Xiao committed
1747
        if(args.size() < 6)
1748
1749
1750
1751
1752
        {
            auto ins = prog.add_instruction(op::undefined{});
            args.insert(args.end(), (6 - args.size()), ins);
        }

Shucai Xiao's avatar
Shucai Xiao committed
1753
1754
        // 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
1755
                                                  std::move(args));
Shucai Xiao's avatar
Shucai Xiao committed
1756

1757
        // second output for the last hidden state
Shucai Xiao's avatar
Shucai Xiao committed
1758
        auto last_output = prog.add_instruction(op::rnn_last_hs_output{}, hidden_states);
Shucai Xiao's avatar
Shucai Xiao committed
1759

Shucai Xiao's avatar
Shucai Xiao committed
1760
        return {hidden_states, last_output};
Shucai Xiao's avatar
Shucai Xiao committed
1761
1762
    }

1763
    std::vector<instruction_ref>
1764
    parse_gru(const std::string&, node_info info, std::vector<instruction_ref> args)
1765
1766
1767
1768
    {
        migraphx::shape input_shape = args[0]->get_shape();
        std::size_t hidden_size     = args[2]->get_shape().lens()[2];

1769
        if(contains(info.attributes, "hidden_size"))
1770
        {
1771
            std::size_t hidden_size_att = parse_value(info.attributes.at("hidden_size")).at<int>();
Shucai Xiao's avatar
Shucai Xiao committed
1772
            if(hidden_size != hidden_size_att)
Shucai Xiao's avatar
Shucai Xiao committed
1773
1774
1775
            {
                MIGRAPHX_THROW("GRU: hidden size mismatch in input and attribute");
            }
1776
1777
1778
1779
        }

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

1785
        op::rnn_direction dirct = op::rnn_direction::forward;
1786
1787
        if(direction == "bidirectional")
        {
1788
            dirct = op::rnn_direction::bidirectional;
1789
1790
1791
        }
        else if(direction == "reverse")
        {
1792
            dirct = op::rnn_direction::reverse;
1793
1794
        }

1795
        std::vector<std::string> vec_names = {"sigmoid", "tanh"};
1796
        if(contains(info.attributes, "activations"))
1797
        {
1798
            auto names = info.attributes.at("activations").strings();
1799
            vec_names.clear();
Shucai Xiao's avatar
Shucai Xiao committed
1800
            vec_names.resize(names.size());
Shucai Xiao's avatar
Shucai Xiao committed
1801
1802
1803
            std::transform(names.begin(), names.end(), vec_names.begin(), [](auto name) {
                return to_lower(name);
            });
1804
1805
        }

1806
        // need 4 activation functions
1807
        if(dirct == op::rnn_direction::bidirectional)
1808
        {
Shucai Xiao's avatar
Shucai Xiao committed
1809
            // 4 activation functions are used in the bidirectional
1810
            // scenario. No spec is provided in onnx::operator. we
Shucai Xiao's avatar
Shucai Xiao committed
1811
1812
            // use the algorithm that: if 1 actv function is provided,
            // repeat 1 four times. If 2 actv functins are provided,
1813
1814
            // 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
1815
1816
1817
            // assume the 3rd one is repeated once and used by the
            // reverse direction.
            // This may need change later
1818
            if(vec_names.size() == 1)
1819
            {
1820
                vec_names.insert(vec_names.end(), 3, vec_names.at(0));
1821
            }
1822
            else if(vec_names.size() == 2)
1823
            {
1824
1825
1826
                // repeat the activation functions
                vec_names.push_back(vec_names.at(0));
                vec_names.push_back(vec_names.at(1));
1827
            }
1828
            else if(vec_names.size() == 3)
1829
            {
1830
                vec_names.push_back(vec_names.at(2));
1831
1832
            }
        }
Shucai Xiao's avatar
Shucai Xiao committed
1833
        else
1834
        {
1835
            if(vec_names.size() == 1)
1836
            {
1837
                vec_names.push_back(vec_names.at(0));
1838
1839
1840
            }
        }

1841
1842
1843
        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
1844
        if(name_it != vec_names.end())
1845
1846
1847
        {
            MIGRAPHX_THROW("GRU: activation function " + std::string(*name_it) + " not supported");
        }
1848

Shucai Xiao's avatar
Shucai Xiao committed
1849
        std::vector<operation> vec_actv_funcs(vec_names.size());
Paul's avatar
Paul committed
1850
1851
1852
1853
        std::transform(vec_names.begin(),
                       vec_names.end(),
                       vec_actv_funcs.begin(),
                       [&](const auto& name) { return map_actv_funcs[name]; });
1854
1855

        float clip = 0.0;
1856
        if(contains(info.attributes, "clip"))
1857
        {
1858
            clip = parse_value(info.attributes.at("clip")).at<float>();
1859
1860
1861
        }

        int linear_before_reset = 0;
1862
        if(contains(info.attributes, "linear_before_reset"))
1863
        {
1864
            linear_before_reset = parse_value(info.attributes.at("linear_before_reset")).at<int>();
1865
1866
        }

Shucai Xiao's avatar
Shucai Xiao committed
1867
        // append undefined opeator to make 6 arguments
Shucai Xiao's avatar
Shucai Xiao committed
1868
        if(args.size() < 6)
Shucai Xiao's avatar
Shucai Xiao committed
1869
1870
1871
1872
1873
        {
            auto ins = prog.add_instruction(op::undefined{});
            args.insert(args.end(), 6 - args.size(), ins);
        }

1874
1875
        // first output for concatenation of hidden states
        auto hidden_states = prog.add_instruction(
Shucai Xiao's avatar
Shucai Xiao committed
1876
            op::gru{hidden_size, vec_actv_funcs, dirct, clip, linear_before_reset},
Shucai Xiao's avatar
Shucai Xiao committed
1877
            std::move(args));
1878
1879

        // second output for last gru output
Shucai Xiao's avatar
Shucai Xiao committed
1880
        auto last_output = prog.add_instruction(op::rnn_last_hs_output{}, hidden_states);
1881

Shucai Xiao's avatar
Shucai Xiao committed
1882
        return {hidden_states, last_output};
1883
1884
    }

Shucai Xiao's avatar
Shucai Xiao committed
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
    void lstm_actv_functions(op::rnn_direction dirct, std::vector<std::string>& actv_func_names)
    {
        // need 6 activation functions for bidirectional directions
        if(dirct == op::rnn_direction::bidirectional)
        {
            // 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
            // if 3 actv funcs are provide, repeat all three once.
            // the same algorithm is used for 4, 5, and 6 actv funcions
            // provided. This may need change later
            switch(actv_func_names.size())
            {
            case 1:
                actv_func_names = {actv_func_names.at(0),
                                   actv_func_names.at(0),
                                   actv_func_names.at(0),
                                   actv_func_names.at(0),
                                   actv_func_names.at(0),
                                   actv_func_names.at(0)};
                break;

            case 2:
                // repeat the 2nd actv func once, then repeat all three another time
                actv_func_names = {actv_func_names.at(0),
                                   actv_func_names.at(1),
                                   actv_func_names.at(1),
                                   actv_func_names.at(0),
                                   actv_func_names.at(1),
                                   actv_func_names.at(1)};
                break;

            case 3:
                // repeat all three actv funcs once
                actv_func_names = {actv_func_names.at(0),
                                   actv_func_names.at(1),
                                   actv_func_names.at(2),
                                   actv_func_names.at(0),
                                   actv_func_names.at(1),
                                   actv_func_names.at(2)};
                break;

            case 4:
                actv_func_names = {actv_func_names.at(0),
                                   actv_func_names.at(1),
                                   actv_func_names.at(2),
                                   actv_func_names.at(3),
                                   actv_func_names.at(3),
                                   actv_func_names.at(3)};
                break;

            case 5:
                actv_func_names = {actv_func_names.at(0),
                                   actv_func_names.at(1),
                                   actv_func_names.at(2),
                                   actv_func_names.at(3),
                                   actv_func_names.at(4),
                                   actv_func_names.at(4)};
                break;

            default: break;
            }
        }
        else
        {
            switch(actv_func_names.size())
            {
            case 1:
                actv_func_names = {
                    actv_func_names.at(0), actv_func_names.at(0), actv_func_names.at(0)};
                break;

            case 2:
                // repeat the 2nd actv func once, so we have 3 actv funcs
                actv_func_names = {
                    actv_func_names.at(0), actv_func_names.at(1), actv_func_names.at(1)};
                break;

            default: break;
            }
        }
    }

Shucai Xiao's avatar
Shucai Xiao committed
1970
    std::vector<instruction_ref>
1971
    parse_lstm(const std::string&, node_info info, std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
1972
1973
1974
1975
    {
        migraphx::shape input_shape = args[0]->get_shape();
        std::size_t hidden_size     = args[2]->get_shape().lens()[2];

1976
        if(contains(info.attributes, "hidden_size"))
Shucai Xiao's avatar
Shucai Xiao committed
1977
        {
1978
            std::size_t hidden_size_att = parse_value(info.attributes.at("hidden_size")).at<int>();
Shucai Xiao's avatar
Shucai Xiao committed
1979
1980
1981
1982
1983
1984
1985
1986
            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"};
1987
        if(contains(info.attributes, "direction"))
Shucai Xiao's avatar
Shucai Xiao committed
1988
        {
1989
            direction = info.attributes.at("direction").s();
Shucai Xiao's avatar
Shucai Xiao committed
1990
1991
        }

Shucai Xiao's avatar
Shucai Xiao committed
1992
        op::rnn_direction dirct = op::rnn_direction::forward;
Shucai Xiao's avatar
Shucai Xiao committed
1993
1994
        if(direction == "bidirectional")
        {
Shucai Xiao's avatar
Shucai Xiao committed
1995
            dirct = op::rnn_direction::bidirectional;
Shucai Xiao's avatar
Shucai Xiao committed
1996
1997
1998
        }
        else if(direction == "reverse")
        {
Shucai Xiao's avatar
Shucai Xiao committed
1999
            dirct = op::rnn_direction::reverse;
Shucai Xiao's avatar
Shucai Xiao committed
2000
        }
Shucai Xiao's avatar
Shucai Xiao committed
2001
        else if(direction == "forward")
Shucai Xiao's avatar
Shucai Xiao committed
2002
        {
Shucai Xiao's avatar
Shucai Xiao committed
2003
            dirct = op::rnn_direction::forward;
Shucai Xiao's avatar
Shucai Xiao committed
2004
2005
2006
2007
2008
2009
        }
        else
        {
            MIGRAPHX_THROW("LSTM: incorrect direction attribute");
        }

2010
        std::vector<std::string> vec_names = {"sigmoid", "tanh", "tanh"};
2011
        if(contains(info.attributes, "activations"))
Shucai Xiao's avatar
Shucai Xiao committed
2012
        {
2013
            auto names = info.attributes.at("activations").strings();
Shucai Xiao's avatar
Shucai Xiao committed
2014
2015
            vec_names.clear();
            vec_names.resize(names.size());
Shucai Xiao's avatar
Shucai Xiao committed
2016
2017
2018
            std::transform(names.begin(), names.end(), vec_names.begin(), [](auto name) {
                return to_lower(name);
            });
Shucai Xiao's avatar
Shucai Xiao committed
2019
2020
        }

Shucai Xiao's avatar
Shucai Xiao committed
2021
        lstm_actv_functions(dirct, vec_names);
Shucai Xiao's avatar
Shucai Xiao committed
2022

2023
2024
2025
        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
2026
        if(name_it != vec_names.end())
2027
2028
2029
        {
            MIGRAPHX_THROW("LSTM: activation function " + std::string(*name_it) + " not supported");
        }
Shucai Xiao's avatar
Shucai Xiao committed
2030
2031

        std::vector<operation> vec_actv_funcs(vec_names.size());
Paul's avatar
Paul committed
2032
2033
2034
2035
        std::transform(vec_names.begin(),
                       vec_names.end(),
                       vec_actv_funcs.begin(),
                       [&](const auto& name) { return map_actv_funcs[name]; });
Shucai Xiao's avatar
Shucai Xiao committed
2036
2037

        float clip = 0.0;
2038
        if(contains(info.attributes, "clip"))
Shucai Xiao's avatar
Shucai Xiao committed
2039
        {
2040
            clip = parse_value(info.attributes.at("clip")).at<float>();
Shucai Xiao's avatar
Shucai Xiao committed
2041
2042
2043
        }

        int input_forget = 0;
2044
        if(contains(info.attributes, "input_forget"))
Shucai Xiao's avatar
Shucai Xiao committed
2045
        {
2046
            input_forget = parse_value(info.attributes.at("input_forget")).at<int>();
Shucai Xiao's avatar
Shucai Xiao committed
2047
2048
2049
2050
2051
2052
        }

        // 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
2053
            args.insert(args.end(), 8 - args.size(), ins);
Shucai Xiao's avatar
Shucai Xiao committed
2054
2055
2056
2057
        }

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

Shucai Xiao's avatar
Shucai Xiao committed
2060
        auto last_output = prog.add_instruction(op::rnn_last_hs_output{}, hidden_states);
Shucai Xiao's avatar
Shucai Xiao committed
2061
2062

        // third output for last cell output
Shucai Xiao's avatar
Shucai Xiao committed
2063
        auto last_cell_output = prog.add_instruction(op::rnn_last_cell_output{}, hidden_states);
Shucai Xiao's avatar
Shucai Xiao committed
2064
2065
2066

        return {hidden_states, last_output, last_cell_output};
    }
2067

2068
2069
2070
2071
    instruction_ref parse_reduce_oper(const std::string&,
                                      const std::string& op_name,
                                      node_info info,
                                      std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
2072
2073
2074
2075
    {
        std::size_t n_dim = args.front()->get_shape().lens().size();

        // default to reduce over all dimensions
2076
        std::vector<int64_t> axes(n_dim);
Shucai Xiao's avatar
Shucai Xiao committed
2077
        std::iota(axes.begin(), axes.end(), 0);
2078
        if(contains(info.attributes, "axes"))
Shucai Xiao's avatar
Shucai Xiao committed
2079
2080
        {
            axes.clear();
2081
            auto&& attr_axes = info.attributes["axes"].ints();
2082
            axes             = std::vector<int64_t>(attr_axes.begin(), attr_axes.end());
Shucai Xiao's avatar
Shucai Xiao committed
2083
2084
2085
        }

        int keep_dims = 1;
2086
        if(contains(info.attributes, "keepdims"))
Shucai Xiao's avatar
Shucai Xiao committed
2087
        {
2088
            keep_dims = parse_value(info.attributes.at("keepdims")).at<int>();
Shucai Xiao's avatar
Shucai Xiao committed
2089
2090
2091
2092
        }

        if(keep_dims == 1)
        {
2093
            return prog.add_instruction(make_op(op_name, {{"axes", axes}}), std::move(args));
Shucai Xiao's avatar
Shucai Xiao committed
2094
2095
2096
        }
        else
        {
2097
            auto ins = prog.add_instruction(make_op(op_name, {{"axes", axes}}), std::move(args));
2098
            return prog.add_instruction(op::squeeze{axes}, ins);
2099
2100
        }
    }
2101

Shucai Xiao's avatar
Shucai Xiao committed
2102
    instruction_ref
2103
    parse_reduce_l1(const std::string&, node_info info, std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
2104
    {
2105
2106
        auto abs_ins = prog.add_instruction(make_op("abs"), args[0]);
        return parse_reduce_oper({}, "reduce_sum", std::move(info), {abs_ins});
Shucai Xiao's avatar
Shucai Xiao committed
2107
2108
2109
    }

    instruction_ref
2110
    parse_reduce_l2(const std::string&, node_info info, std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
2111
    {
2112
2113
2114
        auto square_ins = prog.add_instruction(make_op("mul"), args[0], args[0]);
        auto sum_ins    = parse_reduce_oper({}, "reduce_sum", std::move(info), {square_ins});
        return prog.add_instruction(make_op("sqrt"), sum_ins);
Shucai Xiao's avatar
Shucai Xiao committed
2115
2116
    }

2117
2118
    instruction_ref
    parse_reduce_log_sum(const std::string&, node_info info, std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
2119
    {
2120
2121
        auto sum_ins = parse_reduce_oper({}, "reduce_sum", std::move(info), std::move(args));
        return prog.add_instruction(make_op("log"), sum_ins);
Shucai Xiao's avatar
Shucai Xiao committed
2122
2123
    }

2124
2125
    instruction_ref
    parse_reduce_log_sum_exp(const std::string&, node_info info, std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
2126
    {
2127
2128
2129
        auto exp_ins = prog.add_instruction(make_op("exp"), args[0]);
        auto sum_ins = parse_reduce_oper({}, "reduce_sum", std::move(info), {exp_ins});
        return prog.add_instruction(make_op("log"), sum_ins);
Shucai Xiao's avatar
Shucai Xiao committed
2130
2131
    }

2132
2133
    instruction_ref
    parse_reduce_sum_square(const std::string&, node_info info, std::vector<instruction_ref> args)
Shucai Xiao's avatar
Shucai Xiao committed
2134
    {
2135
2136
        auto square_ins = prog.add_instruction(make_op("mul"), args[0], args[0]);
        return parse_reduce_oper({}, "reduce_sum", std::move(info), {square_ins});
Shucai Xiao's avatar
Shucai Xiao committed
2137
2138
    }

Shucai Xiao's avatar
Shucai Xiao committed
2139
    instruction_ref
2140
    parse_cast(const std::string&, node_info info, std::vector<instruction_ref> args)
2141
    {
2142
        if(!contains(info.attributes, "to"))
2143
2144
2145
2146
        {
            MIGRAPHX_THROW("PARSE_CAST: missing to type attribute!");
        }

2147
        int to_type        = parse_value(info.attributes.at("to")).at<int>();
2148
2149
2150
        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
2151

2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
    std::vector<instruction_ref>
    parse_split(const std::string&, node_info info, std::vector<instruction_ref> args)
    {
        int64_t axis = 0;
        if(contains(info.attributes, "axis"))
        {
            axis = parse_value(info.attributes.at("axis")).at<int>();
        }

        auto lens      = args[0]->get_shape().lens();
        int64_t n_rank = static_cast<int64_t>(lens.size());
        if((axis < -n_rank) || (axis >= n_rank))
        {
            MIGRAPHX_THROW("PARSE_SPLIT: axis attribute out of rank!");
        }
        int64_t tuned_axis = (axis < 0) ? axis + n_rank : axis;

        std::vector<int64_t> vec_splits;
        if(contains(info.attributes, "split"))
        {
            literal s = parse_value(info.attributes.at("split"));
            s.visit([&](auto v) { vec_splits.assign(v.begin(), v.end()); });

            if(std::accumulate(vec_splits.begin(), vec_splits.end(), int64_t(0)) !=
               static_cast<int64_t>(lens[tuned_axis]))
            {
                MIGRAPHX_THROW("PARSE_SPLIT: sum of split attribute unequal to dim size of axis!");
            }
        }
        // no split attribute, input is equally divided
        else
        {
            if((lens[tuned_axis] % info.num_outputs) != 0)
            {
                MIGRAPHX_THROW("PARSE_SPLIT: input cannot be equally divided into " +
                               to_string(info.num_outputs) + " splits!");
            }
            auto dl = lens[tuned_axis] / info.num_outputs;
            vec_splits.resize(info.num_outputs, dl);
        }

        std::vector<instruction_ref> ret_ins;
        int64_t start = 0;
        for(auto sl : vec_splits)
        {
            ret_ins.push_back(
                prog.add_instruction(op::slice{{axis}, {start}, {start + sl}}, args[0]));
            start += sl;
        }

        return ret_ins;
    }

kahmed10's avatar
kahmed10 committed
2205
2206
2207
2208
    instruction_ref
    parse_onehot(const std::string&, node_info info, std::vector<instruction_ref> args)
    {
        migraphx::argument depth_arg = args[1]->eval();
Shucai Xiao's avatar
Shucai Xiao committed
2209
        check_arg_empty(depth_arg, "PARSE_ONEHOT: depth - dynamic shape not supported");
kahmed10's avatar
kahmed10 committed
2210
2211
2212
        size_t depth = depth_arg.at<size_t>();

        int64_t axis = -1;
Shucai Xiao's avatar
Shucai Xiao committed
2213
2214
2215
2216
        if(contains(info.attributes, "axis"))
        {
            axis = info.attributes.at("axis").i();
        }
kahmed10's avatar
kahmed10 committed
2217

Shucai Xiao's avatar
Shucai Xiao committed
2218
        std::vector<float> depth_input(depth * depth, 0.0f);
kahmed10's avatar
kahmed10 committed
2219
2220
        for(int i = 0; i < depth; i++)
        {
Shucai Xiao's avatar
Shucai Xiao committed
2221
            depth_input[depth * i + i] = 1.0f;
kahmed10's avatar
kahmed10 committed
2222
2223
        }

Shucai Xiao's avatar
Shucai Xiao committed
2224
2225
2226
2227
2228
2229
2230
2231
        auto type = args[2]->get_shape().type();
        shape s{type, {depth, depth}};
        auto l_val      = prog.add_literal({s, depth_input});
        auto gather_out = prog.add_instruction(op::gather{0}, {l_val, args[0]});

        // Finally, we need a transpose to move the inner most dim to the axis dim
        int n_rank = gather_out->get_shape().lens().size();
        if(axis < -n_rank or axis >= n_rank)
kahmed10's avatar
kahmed10 committed
2232
        {
Shucai Xiao's avatar
Shucai Xiao committed
2233
            MIGRAPHX_THROW("PARSE_ONEHOT: axis out of range");
kahmed10's avatar
kahmed10 committed
2234
        }
Shucai Xiao's avatar
Shucai Xiao committed
2235
2236
2237
2238
2239
2240
2241
2242
2243
        int64_t tuned_axis = (axis < 0) ? axis + n_rank : axis;
        std::vector<int64_t> perm(n_rank - 1);
        std::iota(perm.begin(), perm.end(), 0);
        perm.insert(perm.begin() + tuned_axis, n_rank - 1);
        auto tr_out = prog.add_instruction(op::transpose{perm}, gather_out);
        auto lens   = tr_out->get_shape().lens();

        auto off_val       = prog.add_instruction(op::slice{{0}, {0}, {1}}, args[2]);
        auto on_val        = prog.add_instruction(op::slice{{0}, {1}, {2}}, args[2]);
2244
        auto diff          = prog.add_instruction(make_op("sub"), on_val, off_val);
Shucai Xiao's avatar
Shucai Xiao committed
2245
2246
        auto unsq_off_val  = prog.add_instruction(op::multibroadcast{lens}, off_val);
        auto unsq_diff_val = prog.add_instruction(op::multibroadcast{lens}, diff);
2247
2248
        auto l_mul         = prog.add_instruction(make_op("mul"), tr_out, unsq_diff_val);
        return prog.add_instruction(make_op("add"), l_mul, unsq_off_val);
kahmed10's avatar
kahmed10 committed
2249
2250
    }

kahmed10's avatar
kahmed10 committed
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
    instruction_ref
    parse_tile(const std::string&, const node_info&, std::vector<instruction_ref> args)
    {
        migraphx::argument arg_s = args[1]->eval();
        check_arg_empty(arg_s, "PARSE_TILE: dynamic shape is not supported");
        std::vector<std::int64_t> repeats;
        arg_s.visit([&](auto input) { repeats.assign(input.begin(), input.end()); });

        auto l0 = args[0];
        for(int i = 0; i < repeats.size(); i++)
        {
            auto l1 = l0;
            for(int j = 1; j < repeats[i]; j++)
            {
                l0 = prog.add_instruction(op::concat{i}, l0, l1);
            }
        }
        return l0;
    }

kahmed10's avatar
kahmed10 committed
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
    instruction_ref
    parse_range(const std::string&, const node_info&, std::vector<instruction_ref> args)
    {

        auto start_arg = args[0]->eval();
        check_arg_empty(start_arg, "PARSE_RANGE: start arg dynamic shape is not supported");
        auto limit_arg = args[1]->eval();
        check_arg_empty(limit_arg, "PARSE_RANGE: limit arg dynamic shape is not supported");
        auto delta_arg = args[2]->eval();
        check_arg_empty(delta_arg, "PARSE_RANGE: delta arg dynamic shape is not supported");

        assert(args[0]->get_shape().elements() == 1 and args[1]->get_shape().elements() == 1 and
               args[2]->get_shape().elements() == 1);

        instruction_ref l0;

        visit_all(start_arg, limit_arg, delta_arg)([&](auto start, auto limit, auto delta) {
            auto start_val = start.front();
            auto limit_val = limit.front();
            auto delta_val = delta.front();

            size_t num_elements = static_cast<size_t>(
                ceil(static_cast<double>(limit_val - start_val) / static_cast<double>(delta_val)));

            assert(num_elements > 0);

            using type = decltype(start_val);

            std::vector<type> range_vals(num_elements);

            std::generate(range_vals.begin(), range_vals.end(), [&]() {
                auto result = start_val;
                start_val += delta_val;
                return result;
            });

            l0 = prog.add_literal({shape{args[0]->get_shape().type(), {num_elements}}, range_vals});
        });
        return l0;
    }

2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
    enum class reduce_mode_t
    {
        sum  = 0,
        mean = 1,
        max  = 2
    };

    instruction_ref parse_embedding_bag(const node_info& info, std::vector<instruction_ref> args)
    {
        if(args[2]->get_shape().elements() != 1)
            MIGRAPHX_THROW("PARSE_EMBEDDING_BAG: MIGraphX only supports offsets of size 1");
        reduce_mode_t reduce_mode = reduce_mode_t::sum;
        if(contains(info.attributes, "mode"))
        {
            reduce_mode = static_cast<reduce_mode_t>(info.attributes.at("mode").i());
        }

        auto l0 = prog.add_instruction(op::gather{}, args[0], args[1]);
        switch(reduce_mode)
        {
2332
2333
2334
2335
2336
2337
2338
2339
2340
        case reduce_mode_t::sum:
            l0 = prog.add_instruction(make_op("reduce_sum", {{"axes", {0}}}), l0);
            break;
        case reduce_mode_t::mean:
            l0 = prog.add_instruction(make_op("reduce_mean", {{"axes", {0}}}), l0);
            break;
        case reduce_mode_t::max:
            l0 = prog.add_instruction(make_op("reduce_max", {{"axes", {0}}}), l0);
            break;
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
        }
        return l0;
    }

    instruction_ref
    parse_aten(const std::string&, const node_info& info, std::vector<instruction_ref> args)
    {
        if(contains(info.attributes, "operator"))
        {
            auto op_name = info.attributes.at("operator").s();
            if(op_name.find("embedding_bag") != std::string::npos)
            {
                return parse_embedding_bag(info, std::move(args));
            }
        }
        MIGRAPHX_THROW("PARSE_ATEN: unsupported custom operator");
    }

Shucai Xiao's avatar
Shucai Xiao committed
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
    template <class T>
    std::vector<std::size_t> nonzero_indices(const std::vector<T>& data)
    {
        std::vector<std::size_t> indices;
        for(std::size_t i = 0; i < data.size(); ++i)
        {
            if(!float_equal(data[i], 0))
                indices.push_back(i);
        }

        return indices;
    }

    instruction_ref
    parse_nonzero(const std::string&, const node_info&, std::vector<instruction_ref> args)
    {
        migraphx::argument data_arg = args.back()->eval();
        check_arg_empty(data_arg, "PARSE_NONZERO: cannot support non-constant input!");

        std::vector<std::size_t> indices;
        data_arg.visit([&](auto val) {
            using val_type = std::remove_cv_t<typename decltype(val)::value_type>;
            std::vector<val_type> vec_data;
            vec_data.assign(val.begin(), val.end());
            indices = this->nonzero_indices(vec_data);
        });

        shape in_s = args[0]->get_shape();
        shape out_s{shape::int64_type, {in_s.lens().size(), indices.size()}};

        std::vector<int64_t> out_data(out_s.elements());
        for(std::size_t i = 0; i < indices.size(); ++i)
        {
            auto idx = in_s.multi(indices[i]);
            for(std::size_t j = 0; j < in_s.lens().size(); ++j)
            {
                out_data[out_s.index({j, i})] = idx[j];
            }
        }

        return prog.add_literal(literal(out_s, out_data));
    }

2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
    instruction_ref
    parse_equal(const std::string&, const node_info&, std::vector<instruction_ref> args)
    {
        auto l = add_broadcastable_binary_op(args[0], args[1], "equal");
        if(l->get_shape().type() != shape::bool_type)
        {
            l = prog.add_instruction(op::convert{shape::bool_type}, l);
        }
        return l;
    }

Paul's avatar
Paul committed
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
    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
2425
            MIGRAPHX_THROW("Failed reading onnx file.");
Paul's avatar
Paul committed
2426
2427
2428
        }
    }

Paul Fultz II's avatar
Paul Fultz II committed
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
    void parse_from(const void* data, std::size_t size)
    {
        onnx::ModelProto model;
        if(model.ParseFromArray(data, size))
        {
            if(model.has_graph())
            {
                this->parse_graph(model.graph());
            }
        }
        else
        {
            MIGRAPHX_THROW("Failed reading onnx file.");
        }
    }

Paul's avatar
Paul committed
2445
2446
    void parse_graph(const onnx::GraphProto& graph)
    {
2447
        for(auto&& f : graph.initializer())
2448
2449
            instructions[f.name()] = prog.add_literal(parse_tensor(f));

Paul's avatar
Paul committed
2450
2451
2452
        for(auto&& input : graph.input())
        {
            const std::string& name = input.name();
2453
2454
            // input not in initializer_data, so it is a real input
            if(!contains(instructions, name))
2455
            {
2456
2457
2458
2459
2460
2461
2462
                std::vector<std::size_t> dims;
                if(map_input_dims.count(name) > 0)
                {
                    dims = map_input_dims.at(name);
                }

                shape s            = parse_type(input.type(), dims);
2463
2464
                instructions[name] = prog.add_parameter(name, s);
            }
Paul's avatar
Paul committed
2465
        }
2466
2467

        for(auto&& node : graph.node())
Paul's avatar
Paul committed
2468
        {
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
            std::vector<instruction_ref> args;
            for(auto&& input : node.input())
            {
                if(input.empty())
                {
                    this->parse_undefined(input);
                }
                if(instructions.count(input) == 0)
                {
                    MIGRAPHX_THROW("PARSE_GRAPH: invalid onnx file. Input \"" + input +
                                   "\" is unavailable due to unordered nodes!");
                }
                args.push_back(instructions.at(input));
            }

            std::vector<instruction_ref> result;
            std::size_t output_num = static_cast<std::size_t>(node.output().size());
            if(ops.count(node.op_type()) == 0)
            {
2488
2489
2490
2491
                if(skip_unknown_operators)
                    result.push_back(prog.add_instruction(op::unknown{node.op_type()}, args));
                else
                    MIGRAPHX_THROW("Unknown operator: " + node.op_type());
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
            }
            else
            {
                result = ops[node.op_type()]({get_attributes(node), output_num}, args);
            }

            output_num = std::min<std::size_t>(output_num, result.size());
            std::transform(node.output().begin(),
                           node.output().begin() + output_num,
                           result.begin(),
                           std::inserter(instructions, instructions.end()),
                           [](auto&& x, auto&& y) { return std::make_pair(x, y); });
Paul's avatar
Paul committed
2504
        }
Shucai Xiao's avatar
Shucai Xiao committed
2505

2506
        // Find instructions corresponding to the output
Shucai Xiao's avatar
Shucai Xiao committed
2507
        auto prog_output = graph.output();
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
        std::vector<std::string> all_output_names;
        std::vector<std::string> prog_output_names;
        std::transform(prog_output.begin(),
                       prog_output.end(),
                       std::back_inserter(all_output_names),
                       [](auto& node) { return node.name(); });
        std::copy_if(
            all_output_names.begin(),
            all_output_names.end(),
            std::back_inserter(prog_output_names),
            [&](const auto& name) { return !(name.empty() or instructions.count(name) == 0); });

        std::vector<instruction_ref> output_ins;
        std::transform(prog_output_names.begin(),
                       prog_output_names.end(),
                       std::back_inserter(output_ins),
                       [&](const auto& name) { return instructions[name]; });

        // add the return instuction
        prog.add_return(output_ins);
Paul's avatar
Paul committed
2528
2529
    }

Shucai Xiao's avatar
Shucai Xiao committed
2530
    void parse_undefined(const std::string& name)
2531
    {
Shucai Xiao's avatar
Shucai Xiao committed
2532
        auto ins           = prog.add_instruction(op::undefined{});
2533
2534
2535
        instructions[name] = ins;
    }

Paul's avatar
Paul committed
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
    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;
    }

Shucai Xiao's avatar
Shucai Xiao committed
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
    static 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 9: return shape::bool_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
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
    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::FLOAT: return literal{attr.f()};
        case onnx::AttributeProto::INT: return literal{attr.i()};
        case onnx::AttributeProto::TENSOR: return parse_tensor(attr.t());
Paul's avatar
Paul committed
2583
        case onnx::AttributeProto::FLOATS: return from_repeated(shape::float_type, attr.floats());
Paul's avatar
Paul committed
2584
        case onnx::AttributeProto::INTS: return from_repeated(shape::int64_type, attr.ints());
Paul's avatar
Paul committed
2585
2586
2587
2588
2589
        case onnx::AttributeProto::UNDEFINED:
        case onnx::AttributeProto::GRAPH:
        case onnx::AttributeProto::STRING:
        case onnx::AttributeProto::STRINGS:
        case onnx::AttributeProto::TENSORS:
2590
2591
        case onnx::AttributeProto::SPARSE_TENSOR:
        case onnx::AttributeProto::SPARSE_TENSORS:
Paul's avatar
Paul committed
2592
2593
        case onnx::AttributeProto::GRAPHS: return {};
        }
Shucai Xiao's avatar
Shucai Xiao committed
2594
        MIGRAPHX_THROW("PARSE_VALUE: Invalid attribute type " + std::to_string(attr.type()));
Paul's avatar
Paul committed
2595
2596
2597
2598
2599
    }

    static literal parse_tensor(const onnx::TensorProto& t)
    {
        std::vector<std::size_t> dims(t.dims().begin(), t.dims().end());
2600
2601
        if(t.has_raw_data())
        {
wsttiger's avatar
wsttiger committed
2602
            const std::string& s = t.raw_data();
Shucai Xiao's avatar
Shucai Xiao committed
2603
2604
            auto type            = get_type(t.data_type());
            return create_literal(type, dims, s.data());
2605
        }
Shucai Xiao's avatar
Shucai Xiao committed
2606

Paul's avatar
Paul committed
2607
2608
        switch(t.data_type())
        {
Shucai Xiao's avatar
Shucai Xiao committed
2609
2610
2611
2612
        case onnx::TensorProto::BOOL: return create_literal(shape::bool_type, dims, t.int32_data());
        case onnx::TensorProto::INT8: return create_literal(shape::int8_type, dims, t.int32_data());
        case onnx::TensorProto::UINT8:
            return create_literal(shape::uint8_type, dims, t.int32_data());
Paul's avatar
Paul committed
2613
        case onnx::TensorProto::INT16:
Shucai Xiao's avatar
Shucai Xiao committed
2614
2615
2616
            return create_literal(shape::int16_type, dims, t.int32_data());
        case onnx::TensorProto::UINT16:
            return create_literal(shape::uint16_type, dims, t.int32_data());
Paul's avatar
Paul committed
2617
        case onnx::TensorProto::INT32:
Khalique's avatar
Khalique committed
2618
            return create_literal(shape::int32_type, dims, t.int32_data());
Shucai Xiao's avatar
Shucai Xiao committed
2619
2620
        case onnx::TensorProto::UINT32:
            return create_literal(shape::uint32_type, dims, t.uint64_data());
Paul's avatar
Paul committed
2621
        case onnx::TensorProto::INT64:
Khalique's avatar
Khalique committed
2622
            return create_literal(shape::int64_type, dims, t.int64_data());
Shucai Xiao's avatar
Shucai Xiao committed
2623
2624
        case onnx::TensorProto::UINT64:
            return create_literal(shape::uint64_type, dims, t.uint64_data());
Paul's avatar
Paul committed
2625
        case onnx::TensorProto::FLOAT16:
Khalique's avatar
Khalique committed
2626
        {
Khalique's avatar
Khalique committed
2627
            std::vector<uint16_t> data_uint16(t.int32_data().begin(), t.int32_data().end());
2628
            std::vector<half> data_half;
Khalique's avatar
Khalique committed
2629
2630
2631
            std::transform(data_uint16.begin(),
                           data_uint16.end(),
                           std::back_inserter(data_half),
2632
                           [](uint16_t raw_val) { return *reinterpret_cast<half*>(&raw_val); });
2633
            return create_literal(shape::half_type, dims, data_half);
Khalique's avatar
Khalique committed
2634
        }
Shucai Xiao's avatar
Shucai Xiao committed
2635
2636
2637
2638
        case onnx::TensorProto::DOUBLE:
            return create_literal(shape::double_type, dims, t.double_data());
        case onnx::TensorProto::FLOAT:
            return create_literal(shape::float_type, dims, t.float_data());
Paul's avatar
Paul committed
2639
2640
2641
        case onnx::TensorProto::UNDEFINED:
        case onnx::TensorProto::STRING:
        case onnx::TensorProto::COMPLEX64:
Paul's avatar
Paul committed
2642
2643
        case onnx::TensorProto::COMPLEX128: throw std::runtime_error("");
        }
Shucai Xiao's avatar
Shucai Xiao committed
2644
        MIGRAPHX_THROW("PARSE_TENSOR: Invalid tensor type");
Paul's avatar
Paul committed
2645
2646
    }

Khalique's avatar
Khalique committed
2647
    static literal
2648
    create_literal(shape::type_t shape_type, const std::vector<size_t>& dims, const char* data)
2649
    {
Khalique's avatar
Khalique committed
2650
        // in case of scalar constants in onnx file, use dims=1 to fill initializer data
2651
        if(dims.empty())
2652
            return literal{{shape_type}, data};
2653
2654
2655
        return literal{{shape_type, dims}, data};
    }

2656
    template <class T, MIGRAPHX_REQUIRES(not std::is_pointer<T>{})>
Khalique's avatar
Khalique committed
2657
    static literal create_literal(shape::type_t shape_type, const std::vector<size_t>& dims, T data)
2658
2659
    {
        if(dims.empty())
2660
            return literal{{shape_type}, data.begin(), data.end()};
2661
        return literal{{shape_type, dims}, data.begin(), data.end()};
2662
2663
    }

2664
    shape parse_type(const onnx::TypeProto& t, const std::vector<std::size_t>& input_dims)
Paul's avatar
Paul committed
2665
    {
Shucai Xiao's avatar
Shucai Xiao committed
2666
        shape::type_t shape_type = get_type(t.tensor_type().elem_type());
2667
2668
2669
2670
2671
        if(!input_dims.empty())
        {
            return {shape_type, input_dims};
        }

Paul's avatar
Paul committed
2672
        std::vector<std::size_t> dims;
Paul's avatar
Paul committed
2673
        auto&& tensor_dims = t.tensor_type().shape().dim();
2674
2675
2676
        std::transform(tensor_dims.begin(),
                       tensor_dims.end(),
                       std::back_inserter(dims),
2677
2678
                       [&](auto&& d) -> std::size_t {
                           if(d.has_dim_value())
2679
                           {
2680
                               if(static_cast<int>(d.dim_value()) <= 0)
2681
2682
2683
                               {
                                   return default_dim_value;
                               }
2684
                               return d.dim_value();
2685
                           }
2686
2687
2688
2689
                           else
                           {
                               return default_dim_value;
                           }
2690
                       });
2691

2692
2693
2694
        if(dims.empty())
            return {shape_type};

Paul's avatar
Paul committed
2695
2696
        return {shape_type, dims};
    }
2697

Shucai Xiao's avatar
Shucai Xiao committed
2698
2699
    void check_arg_empty(const argument& arg, const std::string& msg)
    {
Shucai Xiao's avatar
Shucai Xiao committed
2700
        if(arg.empty())
Shucai Xiao's avatar
Shucai Xiao committed
2701
2702
2703
2704
        {
            MIGRAPHX_THROW(msg);
        }
    }
Paul's avatar
Paul committed
2705
2706
};

Paul Fultz II's avatar
Paul Fultz II committed
2707
template <class... Ts>
2708
program parse_onnx_from(const onnx_options& options, Ts&&... xs)
Paul's avatar
Paul committed
2709
2710
{
    onnx_parser parser;
2711
2712
2713
    parser.map_input_dims         = options.map_input_dims;
    parser.default_dim_value      = options.default_dim_value;
    parser.skip_unknown_operators = options.skip_unknown_operators;
2714

2715
    if(options.print_program_on_error)
Paul's avatar
Paul committed
2716
    {
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
        // Log the program when it can't be parsed
        try
        {
            parser.parse_from(std::forward<Ts>(xs)...);
        }
        catch(...)
        {
            std::cerr << parser.prog << std::endl;
            throw;
        }
Paul's avatar
Paul committed
2727
    }
2728
    else
Paul's avatar
Paul committed
2729
    {
2730
        parser.parse_from(std::forward<Ts>(xs)...);
Paul's avatar
Paul committed
2731
2732
2733
2734
    }
    return std::move(parser.prog);
}

2735
program parse_onnx(const std::string& name, const onnx_options& options)
Paul Fultz II's avatar
Paul Fultz II committed
2736
2737
2738
2739
2740
{
    std::fstream input(name.c_str(), std::ios::in | std::ios::binary);
    return parse_onnx_from(options, input);
}

2741
program parse_onnx_buffer(const std::string& buffer, const onnx_options& options)
Paul Fultz II's avatar
Paul Fultz II committed
2742
2743
2744
2745
{
    return parse_onnx_from(options, buffer.data(), buffer.size());
}

2746
program parse_onnx_buffer(const void* data, std::size_t size, const onnx_options& options)
Paul Fultz II's avatar
Paul Fultz II committed
2747
2748
2749
2750
{
    return parse_onnx_from(options, data, size);
}

Paul's avatar
Paul committed
2751
} // namespace MIGRAPHX_INLINE_NS
Paul's avatar
Paul committed
2752
} // namespace migraphx