Method parse_graph

src/tf/tf_parser.cpp:270–323

}

void tf_parser::parse_graph(const tensorflow::GraphDef& graph)
{
    nodes = get_nodes(graph, input_nodes);
    for(auto&& input : input_nodes)
    {
        const std::string& name   = input.name();
        attribute_map input_attrs = get_attributes(input);
        shape::type_t shape_type  = parse_type(input_attrs.at("dtype").type());
        std::vector<size_t> dims  = parse_dims(input_attrs.at("shape").shape());

        if(contains(map_input_dims, name))
        {
            dims = map_input_dims.at(name);
        }
        else
        {
            if(is_nhwc and dims.size() >= 4)
            {
                this->reorder_data(dims);
            }
            std::transform(dims.begin(), dims.end(), dims.begin(), [&](auto dim) {
                return static_cast<int>(dim) <= 0 ? batch_size : dim;
            });
        }

        shape s            = shape{shape_type, dims};
        instructions[name] = to_nhwc(mm->add_parameter(name, s));
    }
    for(auto&& p : nodes)
    {
        this->parse_node(p.first);
    }
    if(mm->size() == 0)
        return;

    // Needs to add a ret instruction at the end of
    // the program
    if(output_node_names.empty())
    {
        output_node_names = find_outputs();
    }

    std::vector<instruction_ref> output_ins;
    std::transform(output_node_names.begin(),
                   output_node_names.end(),
                   std::back_inserter(output_ins),
                   [&](const auto& output_name) {
                       if(not contains(instructions, output_name))
                           MIGRAPHX_THROW("PARSE_TF: output name " + output_name +
                                          " not found in graph!");
                       return this->to_nchw(instructions[output_name]);
                   });
    mm->add_return(output_ins);
}

void tf_parser::parse_node(const std::string& name)
{