组合图:C 是否有TensorFlow Import_graph_def当量

它不像python那样容易。

您可以用类似的东西加载GraphDef：

#include <string>
#include <tensorflow/core/framework/graph.pb.h>
#include <tensorflow/core/platform/env.h>
tensorflow::GraphDef graph;
std::string graphFileName = "...";
auto status = tensorflow::ReadBinaryProto(
    tensorflow::Env::Default(), graphFileName, &graph);
if (!status.ok()) { /* Error... */ }

然后您可以使用它来创建一个会话：

#include <tensorflow/core/public/session.h>
tensorflow::Session *newSession;
auto status = tensorflow::NewSession(tensorflow::SessionOptions(), &newSession);
if (!status.ok()) { /* Error... */ }
status = session->Create(graph);
if (!status.ok()) { /* Error... */ }

或扩展现有图的图：

status = session->Extend(graph);
if (!status.ok()) { /* Error... */ }

这样，您可以将几个GraphDef S放入同一图。但是，没有其他设施可以提取特定的节点，也没有避免名称碰撞 - 您必须自己找到节点，并且必须确保GraphDef S没有冲突的OP名称。例如，我使用此函数查找所有与给定正则表达式匹配的名称的节点，并按名称排序：

#include <vector>
#include <regex>
#include <tensorflow/core/framework/node_def.pb.h>
std::vector<const tensorflow::NodeDef *> GetNodes(const tensorflow::GraphDef &graph, const std::regex &regex)
{
    std::vector<const tensorflow::NodeDef *> nodes;
    for (const auto &node : graph.node())
    {
        if (std::regex_match(node.name(), regex))
        {
            nodes.push_back(&node);
        }
    }
    std::sort(nodes.begin(), nodes.end(),
              [](const tensorflow::NodeDef *lhs, const tensorflow::NodeDef *rhs)
              {
                  return lhs->name() < rhs->name();
              });
    return nodes;
}

可以通过直接操纵要组合的两个图的graphDefs中的nodedefs来实现这一点。基本算法是定义两个GraphDef，使用占位符将输入到第二个GraphDef，然后将其重定向到第一个GraphDef的输出。这将类似于通过将第二电路的输入连接到第一电路的输出来串联的两个电路。

首先，定义了示例GraphDef，以及观察GraphDefs内部的实用程序。重要的是要注意，两个GraphDefs的所有节点都必须具有唯一的名称。

Status Panel::SampleFirst(GraphDef *graph_def) 
{
    Scope root = Scope::NewRootScope();
    Placeholder p1(root.WithOpName("p1"), DT_INT32);
    Placeholder p2(root.WithOpName("p2"), DT_INT32);
    Add add(root.WithOpName("add"), p1, p2);
    return root.ToGraphDef(graph_def);
}
Status Panel::SampleSecond(GraphDef *graph_def)
{
    Scope root = Scope::NewRootScope();
    Placeholder q1(root.WithOpName("q1"), DT_INT32);
    Placeholder q2(root.WithOpName("q2"), DT_INT32);
    Add sum(root.WithOpName("sum"), q1, q2);
    Multiply multiply(root.WithOpName("multiply"), sum, 4);
    return root.ToGraphDef(graph_def);
}
void Panel::ShowGraphDef(GraphDef &graph_def)
{
    for (int i = 0; i < graph_def.node_size(); i++) {
        NodeDef node_def = graph_def.node(i);
        cout << "NodeDef name is " << node_def.name() << endl;
        cout << "NodeDef op is " << node_def.op() << endl;
        for (const string& input : node_def.input()) {
            cout << "t input: " << input << endl;
        }
    }
}

现在创建了两个GraphDef，第二个GraphDef的输入连接到第一个GraphDef的输出。这是通过在节点上迭代并识别第一个操作节点来完成的，该节点的输入是占位符，并将这些输入重定向到第一个GraphDef的输出。然后将节点添加到第一个GraphDef以及所有后续节点。结果是第二个GraphDef。

Status Panel::Append(vector<Tensor> *outputs)
{
    GraphDef graph_def_first;
    GraphDef graph_def_second;
    TF_RETURN_IF_ERROR(SampleFirst(&graph_def_first));
    TF_RETURN_IF_ERROR(SampleSecond(&graph_def_second));
    for (int i = 0; i < graph_def_second.node_size(); i++) {
        NodeDef node_def = graph_def_second.node(i);
        if (node_def.name() == "sum") {
            node_def.set_input(0, "p1");
            node_def.set_input(1, "add");
        }
        *graph_def_first.add_node() = node_def;
    }
    ShowGraphDef(graph_def_first);
    unique_ptr<Session> session(NewSession(SessionOptions()));
    TF_RETURN_IF_ERROR(session->Create(graph_def_first));
    Tensor t1(2);
    Tensor t2(3);
    vector<pair<string, Tensor>> inputs = {{"p1", t1}, {"p2", t2}};
    TF_RETURN_IF_ERROR(session->Run(inputs, {"multiply"}, {}, outputs));
    return Status::OK();
}

此特定图将采用两个输入2和3，并将它们添加在一起。然后，该(5(的总和将再次添加到第一个输入(2(，然后乘以4，以获得28的结果。(((2 3( 2( * 4 = 4 = 28。