onnx_parser.cpp 19.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
Paul Fultz II's avatar
Paul Fultz II committed
24
25
26
27
28
29
30
#include <migraphx/onnx/onnx_parser.hpp>
#include <migraphx/onnx/op_parser.hpp>
#include <migraphx/fallthrough.hpp>
#include <migraphx/make_op.hpp>
#include <migraphx/stringutils.hpp>
#include <migraphx/ranges.hpp>
#include <migraphx/instruction.hpp>
31
#include <migraphx/common.hpp>
Paul Fultz II's avatar
Paul Fultz II committed
32
33
34
35
36
#include <migraphx/type_traits.hpp>
#include <migraphx/float_equal.hpp>
#include <migraphx/file_buffer.hpp>
#include <migraphx/filesystem.hpp>
#include <migraphx/op/unknown.hpp>
37
#include <migraphx/env.hpp>
Paul Fultz II's avatar
Paul Fultz II committed
38
39
40

namespace migraphx {
inline namespace MIGRAPHX_INLINE_NS {
41

Paul Fultz II's avatar
Paul Fultz II committed
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
namespace onnx {

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

static literal
create_literal(shape::type_t shape_type, const std::vector<size_t>& dims, const char* data)
{
Shucai Xiao's avatar
Shucai Xiao committed
57
58
59
60
61
    // empty input
    auto elem_num =
        std::accumulate(dims.begin(), dims.end(), std::size_t(1), std::multiplies<std::size_t>());
    if(elem_num == 0)
    {
62
        return literal{shape_type};
Shucai Xiao's avatar
Shucai Xiao committed
63
64
    }

Paul Fultz II's avatar
Paul Fultz II committed
65
66
67
68
69
70
71
72
73
    // in case of scalar constants in onnx file, use dims=1 to fill initializer data
    if(dims.empty())
        return literal{{shape_type}, data};
    return literal{{shape_type, dims}, data};
}

template <class T, MIGRAPHX_REQUIRES(not std::is_pointer<T>{})>
static literal create_literal(shape::type_t shape_type, const std::vector<size_t>& dims, T data)
{
Shucai Xiao's avatar
Shucai Xiao committed
74
75
76
77
78
    // empty input
    auto elem_num =
        std::accumulate(dims.begin(), dims.end(), std::size_t(1), std::multiplies<std::size_t>());
    if(elem_num == 0)
    {
79
        return literal{shape_type};
Shucai Xiao's avatar
Shucai Xiao committed
80
81
82
    }

    // scalar input
Paul Fultz II's avatar
Paul Fultz II committed
83
84
85
86
87
88
89
90
91
92
93
94
95
96
    if(dims.empty())
        return literal{{shape_type}, data.begin(), data.end()};
    return literal{{shape_type, dims}, data.begin(), data.end()};
}

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

instruction_ref onnx_parser::node_info::make_contiguous(instruction_ref ins) const
{
Shucai Xiao's avatar
Shucai Xiao committed
97
98
99
    auto attr       = ins->get_operator().to_value();
    std::string key = "require_std_shape";
    if((attr.get(key, false)) or (not ins->get_shape().standard()))
Paul Fultz II's avatar
Paul Fultz II committed
100
    {
Shucai Xiao's avatar
Shucai Xiao committed
101
        return add_instruction(make_op("contiguous"), ins);
Paul Fultz II's avatar
Paul Fultz II committed
102
103
    }

Shucai Xiao's avatar
Shucai Xiao committed
104
    return ins;
Paul Fultz II's avatar
Paul Fultz II committed
105
106
107
108
109
110
111
112
}

instruction_ref onnx_parser::node_info::add_bias(const std::vector<instruction_ref>& args,
                                                 instruction_ref curr_ins,
                                                 uint64_t axis) const
{
    if(args.size() == 3)
    {
Charlie Lin's avatar
Charlie Lin committed
113
114
115
116
117
118
119
120
121
122
123
124
125
        instruction_ref bias_bcast;
        // if curr_ins has a dynamic output shape use 2 input broadcast
        if(curr_ins->get_shape().dynamic())
        {
            bias_bcast =
                mod->add_instruction(make_op("broadcast", {{"axis", axis}}), args[2], curr_ins);
        }
        else
        {
            bias_bcast = mod->add_instruction(
                make_op("broadcast", {{"axis", axis}, {"out_lens", curr_ins->get_shape().lens()}}),
                args[2]);
        }
Shucai Xiao's avatar
Shucai Xiao committed
126
        return mod->add_instruction(make_op("add"), curr_ins, bias_bcast);
Paul Fultz II's avatar
Paul Fultz II committed
127
128
129
130
131
132
133
134
    }
    return curr_ins;
}

instruction_ref onnx_parser::node_info::add_broadcastable_binary_op(const std::string& op_name,
                                                                    instruction_ref arg0,
                                                                    instruction_ref arg1) const
{
135
136
137
138
139
140
141
    return this->add_common_op(op_name, arg0, arg1);
}

instruction_ref onnx_parser::node_info::add_common_op(const std::string& op_name,
                                                      std::vector<instruction_ref> inputs) const
{
    return migraphx::add_common_op(*mod, make_op(op_name), std::move(inputs));
Paul Fultz II's avatar
Paul Fultz II committed
142
143
144
145
146
147
}

instruction_ref
onnx_parser::node_info::add_instruction(const operation& op,
                                        const std::vector<instruction_ref>& args) const
{
Shucai Xiao's avatar
Shucai Xiao committed
148
    return mod->add_instruction(op, args);
Paul Fultz II's avatar
Paul Fultz II committed
149
150
}

Shucai Xiao's avatar
Shucai Xiao committed
151
152
153
154
155
156
157
instruction_ref onnx_parser::node_info::add_instruction(const operation& op,
                                                        const std::vector<instruction_ref>& args,
                                                        const std::vector<module_ref>& mods) const
{
    return mod->add_instruction(op, args, mods);
}

Paul Fultz II's avatar
Paul Fultz II committed
158
159
instruction_ref onnx_parser::node_info::add_literal(literal l) const
{
Shucai Xiao's avatar
Shucai Xiao committed
160
    return mod->add_literal(std::move(l));
Paul Fultz II's avatar
Paul Fultz II committed
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
}

onnx_parser::onnx_parser()
{
    // Add all registered op parsers
    for(auto&& name : get_op_parsers())
        ops.emplace(name, get_op_parser(name));
}

operation onnx_parser::load(const std::string& name, const node_info& info) const
{
    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;
}

Shucai Xiao's avatar
Shucai Xiao committed
198
void onnx_parser::parse_undefined(module* mod, const std::string& name)
Paul Fultz II's avatar
Paul Fultz II committed
199
{
200
    if(not contains(instructions, name))
Paul Fultz II's avatar
Paul Fultz II committed
201
    {
Shucai Xiao's avatar
Shucai Xiao committed
202
        auto ins           = mod->add_instruction(make_op("undefined"));
Paul Fultz II's avatar
Paul Fultz II committed
203
204
205
206
207
208
        instructions[name] = ins;
    }
}

void onnx_parser::parse_from(std::istream& is, std::string name)
{
Shucai Xiao's avatar
Shucai Xiao committed
209
    auto* mm         = prog.get_main_module();
Paul Fultz II's avatar
Paul Fultz II committed
210
211
212
213
214
215
216
217
    this->filename   = std::move(name);
    auto parent_path = fs::path(this->filename).parent_path();
    if(not parent_path.empty())
        this->path = parent_path;

    onnx::ModelProto model;
    if(model.ParseFromIstream(&is))
    {
Shucai Xiao's avatar
Shucai Xiao committed
218
219
220
        auto version  = get_opset_version(model);
        opset_version = (version == -1) ? opset_version : version;

Paul Fultz II's avatar
Paul Fultz II committed
221
222
        if(model.has_graph())
        {
223
            (void)this->parse_graph(mm, model.graph());
Paul Fultz II's avatar
Paul Fultz II committed
224
225
226
227
        }
    }
    else
    {
Shucai Xiao's avatar
Shucai Xiao committed
228
        MIGRAPHX_THROW("PARSE_FROM: Failed reading onnx file: " + this->filename);
Paul Fultz II's avatar
Paul Fultz II committed
229
230
231
232
233
    }
}

void onnx_parser::parse_from(const void* data, std::size_t size)
{
Shucai Xiao's avatar
Shucai Xiao committed
234
    auto* mm = prog.get_main_module();
Paul Fultz II's avatar
Paul Fultz II committed
235
236
237
    onnx::ModelProto model;
    if(model.ParseFromArray(data, size))
    {
Shucai Xiao's avatar
Shucai Xiao committed
238
239
240
        auto version  = get_opset_version(model);
        opset_version = (version == -1) ? opset_version : version;

Paul Fultz II's avatar
Paul Fultz II committed
241
242
        if(model.has_graph())
        {
243
            (void)this->parse_graph(mm, model.graph());
Paul Fultz II's avatar
Paul Fultz II committed
244
245
246
247
248
249
250
251
        }
    }
    else
    {
        MIGRAPHX_THROW("Failed reading onnx file.");
    }
}

Shucai Xiao's avatar
Shucai Xiao committed
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
int64_t onnx_parser::get_opset_version(const onnx::ModelProto& model)
{
    const auto& opset_import = model.opset_import();
    int64_t version          = -1;
    for(const auto& opset : opset_import)
    {
        if(opset.has_version())
        {
            version = std::max(version, opset.version());
        }
    }

    return version;
}

267
268
std::vector<instruction_ref>
onnx_parser::parse_graph(module* mod, const onnx::GraphProto& graph, bool inlining)
Paul Fultz II's avatar
Paul Fultz II committed
269
{
Shucai Xiao's avatar
Shucai Xiao committed
270
    std::unordered_map<std::string, instruction_ref> mod_insts;
Paul Fultz II's avatar
Paul Fultz II committed
271
272
    for(auto&& f : graph.initializer())
    {
Paul's avatar
Paul committed
273
        // std::cout << "initializer: " << f.name() << std::endl;
Shucai Xiao's avatar
Shucai Xiao committed
274
275
        // backup instructions in parent mod
        mod_insts[f.name()] = mod->add_literal(parse_tensor(f));
Paul's avatar
Paul committed
276
        // mod->debug_print(mod_insts[f.name()]);
Paul Fultz II's avatar
Paul Fultz II committed
277
278
279
280
281
282
    }

    for(auto&& input : graph.input())
    {
        const std::string& name = input.name();
        // input not in initializer_data, so it is a real input
283
        if(not contains(mod_insts, name))
Paul Fultz II's avatar
Paul Fultz II committed
284
        {
285
            // ONNX specification does not specify how to deal with the
Shucai Xiao's avatar
Shucai Xiao committed
286
287
288
289
290
291
292
293
294
            // scenario that a nested subgraph contains a parameter with the
            // name existed in its parent graph.
            // In the current implementation, MIGraphX throws an exception for that.
            if(contains(instructions, name))
            {
                MIGRAPHX_THROW("module \"" + mod->name() + "\" has parameter name \"" + name +
                               "\" existing in parent graph!");
            }

295
            shape s;
Paul Fultz II's avatar
Paul Fultz II committed
296
297
298
299
            std::vector<std::size_t> dims;
            if(map_input_dims.count(name) > 0)
            {
                dims = map_input_dims.at(name);
300
301
302
303
304
305
306
307
308
309
                s    = parse_type(input.type(), dims);
            }
            else if(map_dyn_input_dims.count(name) > 0)
            {
                shape::type_t shape_type = get_type(input.type().tensor_type().elem_type());
                s                        = {shape_type, map_dyn_input_dims.at(name)};
            }
            else
            {
                s = parse_type(input.type(), dims);
Paul Fultz II's avatar
Paul Fultz II committed
310
            }
Shucai Xiao's avatar
Shucai Xiao committed
311
            mod_insts[name] = mod->add_parameter(name, s);
Paul Fultz II's avatar
Paul Fultz II committed
312
313
314
        }
    }

Shucai Xiao's avatar
Shucai Xiao committed
315
316
    std::copy(mod_insts.begin(), mod_insts.end(), std::inserter(instructions, instructions.end()));

Paul Fultz II's avatar
Paul Fultz II committed
317
318
319
320
321
322
323
    for(auto&& node : graph.node())
    {
        std::vector<instruction_ref> args;
        for(auto&& input : node.input())
        {
            if(input.empty())
            {
Shucai Xiao's avatar
Shucai Xiao committed
324
                this->parse_undefined(mod, input);
Paul Fultz II's avatar
Paul Fultz II committed
325
326
327
328
329
330
331
332
333
            }
            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));
        }

Paul's avatar
Paul committed
334
335
        std::cout << "operator: " << node.op_type() << std::endl;

Paul Fultz II's avatar
Paul Fultz II committed
336
337
338
339
340
        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)
        {
            if(skip_unknown_operators)
Shucai Xiao's avatar
Shucai Xiao committed
341
                result.push_back(mod->add_instruction(op::unknown{node.op_type()}, args));
Paul Fultz II's avatar
Paul Fultz II committed
342
343
344
345
346
            else
                MIGRAPHX_THROW("Unknown operator: " + node.op_type());
        }
        else
        {
Shucai Xiao's avatar
Shucai Xiao committed
347
348
349
            std::string node_name = node.op_type() + "_" + std::to_string(mod->size());
            result                = ops[node.op_type()](
                *this, {get_attributes(node), output_num, node_name, mod}, args);
Paul Fultz II's avatar
Paul Fultz II committed
350
351
352
353
354
355
356
357
        }

        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
358
359
        std::vector<instruction_ref> added_instructions;
        fix([&](auto self, auto r) {
Paul's avatar
Format  
Paul committed
360
            for(auto ins : r)
Paul's avatar
Paul committed
361
362
363
364
365
366
367
368
            {
                if(contains(args, ins))
                    continue;
                self(ins->inputs());
                added_instructions.push_back(ins);
            }
        })(result);
        mod->debug_print(added_instructions);
Paul Fultz II's avatar
Paul Fultz II committed
369
370
371
372
373
374
375
376
377
378
379
380
381
382
    }

    // Find instructions corresponding to the output
    auto prog_output = graph.output();
    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),
383
        [&](const auto& name) { return not(name.empty() or instructions.count(name) == 0); });
Paul Fultz II's avatar
Paul Fultz II committed
384
385
386
387
388
389
390

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

391
392
393
394
395
396
397
398
    if(not inlining)
    {
        // add the return instuction
        mod->add_return(output_ins);

        // Remove instructions added in module (this is turned off for subgraph inlining)
        erase_if(instructions, [&](auto&& p) { return mod->has_instruction(p.second); });
    }
Shucai Xiao's avatar
Shucai Xiao committed
399

400
    return output_ins;
Paul Fultz II's avatar
Paul Fultz II committed
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
}

literal onnx_parser::parse_value(const onnx::AttributeProto& attr) const
{
    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());
    case onnx::AttributeProto::FLOATS: return from_repeated(shape::float_type, attr.floats());
    case onnx::AttributeProto::INTS: return from_repeated(shape::int64_type, attr.ints());
    case onnx::AttributeProto::UNDEFINED:
    case onnx::AttributeProto::GRAPH:
    case onnx::AttributeProto::STRING:
    case onnx::AttributeProto::STRINGS:
    case onnx::AttributeProto::TENSORS:
    case onnx::AttributeProto::SPARSE_TENSOR:
    case onnx::AttributeProto::SPARSE_TENSORS:
    case onnx::AttributeProto::GRAPHS: return {};
    }
    MIGRAPHX_THROW("PARSE_VALUE: Invalid attribute type " + std::to_string(attr.type()));
}

literal onnx_parser::parse_tensor(const onnx::TensorProto& t) const
{
    std::vector<std::size_t> dims(t.dims().begin(), t.dims().end());
427
428
429
430
    auto type = get_type(t.data_type());
    shape tensor_shape(type, dims);
    auto external_data = t.external_data();
    if(not external_data.empty())
Paul Fultz II's avatar
Paul Fultz II committed
431
    {
432
433
434
435
436
437
438
439
440
441
442
443
444
445
        const std::string& data_file = external_data.at(0).value();
        size_t num_data_fields       = external_data.size();
        size_t offset                = 0;
        size_t nbytes                = tensor_shape.bytes();

        if(num_data_fields > 1) // if offset field is present
        {
            offset = std::stoul(t.external_data().at(1).value());
        }
        if(num_data_fields > 2) // if nbytes field is present
        {
            nbytes = std::stoul(t.external_data().at(2).value());
        }
        auto raw_buffer = read_buffer(path + "/" + data_file, offset, nbytes);
Paul Fultz II's avatar
Paul Fultz II committed
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
        std::string s(raw_buffer.begin(), raw_buffer.end());
        return create_literal(type, dims, s.data());
    }
    if(t.has_raw_data())
    {
        const std::string& s = t.raw_data();
        return create_literal(type, dims, s.data());
    }

    switch(t.data_type())
    {
    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());
    case onnx::TensorProto::INT16: return create_literal(shape::int16_type, dims, t.int32_data());
    case onnx::TensorProto::UINT16: return create_literal(shape::uint16_type, dims, t.int32_data());
    case onnx::TensorProto::INT32: return create_literal(shape::int32_type, dims, t.int32_data());
    case onnx::TensorProto::UINT32:
        return create_literal(shape::uint32_type, dims, t.uint64_data());
    case onnx::TensorProto::INT64: return create_literal(shape::int64_type, dims, t.int64_data());
    case onnx::TensorProto::UINT64:
        return create_literal(shape::uint64_type, dims, t.uint64_data());
bpickrel's avatar
bpickrel committed
468
    case onnx::TensorProto::FLOAT16: {
Paul Fultz II's avatar
Paul Fultz II committed
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
        std::vector<uint16_t> data_uint16(t.int32_data().begin(), t.int32_data().end());
        std::vector<half> data_half;
        std::transform(data_uint16.begin(),
                       data_uint16.end(),
                       std::back_inserter(data_half),
                       [](uint16_t raw_val) { return *reinterpret_cast<half*>(&raw_val); });
        return create_literal(shape::half_type, dims, data_half);
    }
    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());
    case onnx::TensorProto::UNDEFINED:
    case onnx::TensorProto::STRING:
    case onnx::TensorProto::COMPLEX64:
    case onnx::TensorProto::COMPLEX128: throw std::runtime_error("");
    }
    MIGRAPHX_THROW("PARSE_TENSOR: Invalid tensor type");
}
shape onnx_parser::parse_type(const onnx::TypeProto& t,
                              const std::vector<std::size_t>& input_dims) const
{
    shape::type_t shape_type = get_type(t.tensor_type().elem_type());
491
    if(not input_dims.empty())
Paul Fultz II's avatar
Paul Fultz II committed
492
493
494
495
    {
        return {shape_type, input_dims};
    }

496
    std::vector<shape::dynamic_dimension> dynamic_dims;
Paul Fultz II's avatar
Paul Fultz II committed
497
498
499
    auto&& tensor_dims = t.tensor_type().shape().dim();
    std::transform(tensor_dims.begin(),
                   tensor_dims.end(),
500
501
                   std::back_inserter(dynamic_dims),
                   [&](auto&& d) -> shape::dynamic_dimension {
Paul Fultz II's avatar
Paul Fultz II committed
502
503
504
505
                       if(d.has_dim_value())
                       {
                           if(static_cast<int>(d.dim_value()) <= 0)
                           {
506
                               return default_dyn_dim_value;
Paul Fultz II's avatar
Paul Fultz II committed
507
                           }
508
                           std::size_t tmp = d.dim_value();
509
                           return {tmp, tmp};
Paul Fultz II's avatar
Paul Fultz II committed
510
511
512
                       }
                       else
                       {
513
                           return default_dyn_dim_value;
Paul Fultz II's avatar
Paul Fultz II committed
514
515
516
                       }
                   });

517
518
    if(dynamic_dims.empty())
    {
Paul Fultz II's avatar
Paul Fultz II committed
519
        return {shape_type};
520
521
522
523
524
525
526
527
528
529
530
    }
    if(std::all_of(dynamic_dims.begin(), dynamic_dims.end(), [](auto dd) { return dd.is_fixed(); }))
    {
        std::vector<std::size_t> dims;
        std::transform(dynamic_dims.begin(),
                       dynamic_dims.end(),
                       std::back_inserter(dims),
                       [](auto d) { return d.max; });
        return {shape_type, dims};
    }
    return {shape_type, dynamic_dims};
Paul Fultz II's avatar
Paul Fultz II committed
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
}

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;
bpickrel's avatar
bpickrel committed
549
550
    default: {
        MIGRAPHX_THROW("Prototensor data type " + std::to_string(dtype) + " not supported");
Paul Fultz II's avatar
Paul Fultz II committed
551
552
553
554
    }
    }
}

555
556
557
bool is_type_float(shape::type_t dtype)
{
    bool r = false;
558
    if(dtype == shape::float_type or dtype == shape::double_type or dtype == shape::half_type)
559
560
561
562
563
564
    {
        r = true;
    }
    return r;
}

Paul Fultz II's avatar
Paul Fultz II committed
565
566
567
} // namespace onnx
} // namespace MIGRAPHX_INLINE_NS
} // namespace migraphx