Method parse_graph

src/onnx/onnx_parser.cpp:525–634

}

std::vector<instruction_ref>
onnx_parser::parse_graph(module* mod, const onnx::GraphProto& graph, bool inlining)
{
    std::vector<size_t> node_indices(graph.node_size());

    if(check_sorted(graph, parent_input_nodes))
    {
        std::iota(node_indices.begin(), node_indices.end(), 0);
    }
    else
    {
        std::cerr << "Warning: onnx model is not topologically sorted. Attempting to sort..."
                  << std::endl;
        node_indices = toposort(graph);
    }

    std::unordered_map<std::string, instruction_ref> mod_insts =
        parse_intializer(*this, mod, graph);

    mod_insts = parse_inputs(*this, mod, graph, mod_insts);

    std::copy(mod_insts.begin(), mod_insts.end(), std::inserter(instructions, instructions.end()));

    for(auto& node_index : node_indices)
    {
        const onnx::NodeProto& node = graph.node(node_index);
        if(enabled(MIGRAPHX_TRACE_ONNX_PARSER{}))
        {
            std::cout << "operator: " << node.op_type() << '\t' << node.name() << std::endl;
            for(auto&& attr : node.attribute())
            {
                std::cout << "    " << attr.name() << " = " << to_string(attr) << std::endl;
            }
        }

        std::vector<instruction_ref> args;
        for(auto&& input : node.input())
        {
            if(input.empty())
            {
                this->parse_undefined(mod, 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 = node.output().size();
        if(ops.count(node.op_type()) == 0)
        {
            if(skip_unknown_operators)
                result.push_back(mod->add_instruction(op::unknown{node.op_type()}, args));
            else
                MIGRAPHX_THROW("Unknown operator: " + node.op_type());