การสร้างกราฟใน C++

เครื่องมือสร้างกราฟ C++ เป็นเครื่องมือที่มีประสิทธิภาพสำหรับ

• การสร้างกราฟที่ซับซ้อน
• กราฟเปรียบเทียบ (เช่น การตั้งค่าผู้รับมอบสิทธิ์ใน InferenceCalculator, การเปิดใช้/ปิดใช้ส่วนต่างๆ ของกราฟ)
• การกรองข้อมูลที่ซ้ำกันออก (เช่น คุณสามารถใช้โค้ดเดียวในการสร้างกราฟที่ต้องใช้แทน CPU และ GPU โดยเฉพาะใน pbtxt ได้) โดยต้องแชร์ให้มากที่สุด)
• การรองรับอินพุต/เอาต์พุตกราฟแบบไม่บังคับ
• การปรับแต่งกราฟตามแพลตฟอร์ม

การใช้งานพื้นฐาน

มาดูวิธีใช้เครื่องมือสร้างกราฟ C++ สำหรับกราฟง่ายๆ กัน

# Graph inputs.
input_stream: "input_tensors"
input_side_packet: "model"

# Graph outputs.
output_stream: "output_tensors"

node {
  calculator: "InferenceCalculator"
  input_stream: "TENSORS:input_tensors"
  input_side_packet: "MODEL:model"
  output_stream: "TENSORS:output_tensors"
  options: {
    [drishti.InferenceCalculatorOptions.ext] {
      # Requesting GPU delegate.
      delegate { gpu {} }
    }
  }
}

ฟังก์ชันในการสร้าง CalculatorGraphConfig ข้างต้นอาจมีลักษณะดังนี้

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Graph inputs.
  Stream<std::vector<Tensor>> input_tensors =
      graph.In(0).SetName("input_tensors").Cast<std::vector<Tensor>>();
  SidePacket<TfLiteModelPtr> model =
      graph.SideIn(0).SetName("model").Cast<TfLiteModelPtr>();

  auto& inference_node = graph.AddNode("InferenceCalculator");
  auto& inference_opts =
      inference_node.GetOptions<InferenceCalculatorOptions>();
  // Requesting GPU delegate.
  inference_opts.mutable_delegate()->mutable_gpu();
  input_tensors.ConnectTo(inference_node.In("TENSORS"));
  model.ConnectTo(inference_node.SideIn("MODEL"));
  Stream<std::vector<Tensor>> output_tensors =
      inference_node.Out("TENSORS").Cast<std::vector<Tensor>>();

  // Graph outputs.
  output_tensors.SetName("output_tensors").ConnectTo(graph.Out(0));

  // Get `CalculatorGraphConfig` to pass it into `CalculatorGraph`
  return graph.GetConfig();
}

สรุปสั้นๆ

• ใช้ Graph::In/SideIn เพื่อรับอินพุตกราฟเป็น Stream/SidePacket
• ใช้ Node::Out/SideOut เพื่อรับเอาต์พุตโหนดเป็น Stream/SidePacket
• ใช้ Stream/SidePacket::ConnectTo เพื่อเชื่อมต่อสตรีมและแพ็กเกตด้านข้างกับอินพุตของโหนด (Node::In/SideIn) และเอาต์พุตกราฟ (Graph::Out/SideOut)
  • มีโอเปอเรเตอร์ "ทางลัด" >> ที่คุณสามารถใช้แทนฟังก์ชัน ConnectTo ได้ (เช่น x >> node.In("IN"))
• Stream/SidePacket::Cast ใช้เพื่อแคสต์สตรีมหรือแพ็กเกตด้านข้างของ AnyType (เช่น Stream<AnyType> in = graph.In(0);) ไปยังประเภทที่เฉพาะเจาะจง
  • การใช้ประเภทจริงแทน AnyType จะช่วยให้คุณมีเส้นทางที่ดียิ่งขึ้นในการปลดล็อกความสามารถของเครื่องมือสร้างกราฟและปรับปรุงการอ่านกราฟ

การใช้งานขั้นสูง

ฟังก์ชันยูทิลิตี

เรามาแยกโค้ดการสร้างการอนุมานออกมาเป็นฟังก์ชันยูทิลิตีโดยเฉพาะกัน เพื่อช่วยให้อ่านง่ายและนำโค้ดมาใช้ซ้ำได้

// Updates graph to run inference.
Stream<std::vector<Tensor>> RunInference(
    Stream<std::vector<Tensor>> tensors, SidePacket<TfLiteModelPtr> model,
    const InferenceCalculatorOptions::Delegate& delegate, Graph& graph) {
  auto& inference_node = graph.AddNode("InferenceCalculator");
  auto& inference_opts =
      inference_node.GetOptions<InferenceCalculatorOptions>();
  *inference_opts.mutable_delegate() = delegate;
  tensors.ConnectTo(inference_node.In("TENSORS"));
  model.ConnectTo(inference_node.SideIn("MODEL"));
  return inference_node.Out("TENSORS").Cast<std::vector<Tensor>>();
}

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Graph inputs.
  Stream<std::vector<Tensor>> input_tensors =
      graph.In(0).SetName("input_tensors").Cast<std::vector<Tensor>>();
  SidePacket<TfLiteModelPtr> model =
      graph.SideIn(0).SetName("model").Cast<TfLiteModelPtr>();

  InferenceCalculatorOptions::Delegate delegate;
  delegate.mutable_gpu();
  Stream<std::vector<Tensor>> output_tensors =
      RunInference(input_tensors, model, delegate, graph);

  // Graph outputs.
  output_tensors.SetName("output_tensors").ConnectTo(graph.Out(0));

  return graph.GetConfig();
}

ด้วยเหตุนี้ RunInference จึงมีอินเทอร์เฟซที่ชัดเจนซึ่งระบุอินพุต/เอาต์พุตและประเภทของอินพุต

ซึ่งนำกลับมาใช้ใหม่ได้ง่ายๆ เช่น เขียนเพียงไม่กี่บรรทัดเมื่อต้องการเรียกใช้การอนุมานโมเดลเพิ่มเติม

  // Run first inference.
  Stream<std::vector<Tensor>> output_tensors =
      RunInference(input_tensors, model, delegate, graph);
  // Run second inference on the output of the first one.
  Stream<std::vector<Tensor>> extra_output_tensors =
      RunInference(output_tensors, extra_model, delegate, graph);

และคุณไม่จำเป็นต้องสร้างชื่อและแท็กซ้ำ (InferenceCalculator, TENSORS, MODEL) หรือแนะนำค่าคงที่เฉพาะตรงนี้ รายละเอียดเหล่านั้นจะได้รับการแปลเป็นฟังก์ชัน RunInference

คลาสยูทิลิตี

และแน่นอนว่านอกจากฟังก์ชันแล้ว ยังมีประโยชน์คือแนะนำคลาสยูทิลิตีที่จะช่วยให้โค้ดการสร้างกราฟอ่านง่ายขึ้นและเกิดข้อผิดพลาดน้อยลง

MediaPipe มีเครื่องคำนวณ PassThroughCalculator ซึ่งส่งผ่านอินพุตเพียงอย่างเดียว ดังนี้

input_stream: "float_value"
input_stream: "int_value"
input_stream: "bool_value"

output_stream: "passed_float_value"
output_stream: "passed_int_value"
output_stream: "passed_bool_value"

node {
  calculator: "PassThroughCalculator"
  input_stream: "float_value"
  input_stream: "int_value"
  input_stream: "bool_value"
  # The order must be the same as for inputs (or you can use explicit indexes)
  output_stream: "passed_float_value"
  output_stream: "passed_int_value"
  output_stream: "passed_bool_value"
}

มาดูโค้ดการสร้าง C++ ที่ตรงไปตรงมาเพื่อสร้างกราฟข้างต้นกัน

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Graph inputs.
  Stream<float> float_value = graph.In(0).SetName("float_value").Cast<float>();
  Stream<int> int_value = graph.In(1).SetName("int_value").Cast<int>();
  Stream<bool> bool_value = graph.In(2).SetName("bool_value").Cast<bool>();

  auto& pass_node = graph.AddNode("PassThroughCalculator");
  float_value.ConnectTo(pass_node.In("")[0]);
  int_value.ConnectTo(pass_node.In("")[1]);
  bool_value.ConnectTo(pass_node.In("")[2]);
  Stream<float> passed_float_value = pass_node.Out("")[0].Cast<float>();
  Stream<int> passed_int_value = pass_node.Out("")[1].Cast<int>();
  Stream<bool> passed_bool_value = pass_node.Out("")[2].Cast<bool>();

  // Graph outputs.
  passed_float_value.SetName("passed_float_value").ConnectTo(graph.Out(0));
  passed_int_value.SetName("passed_int_value").ConnectTo(graph.Out(1));
  passed_bool_value.SetName("passed_bool_value").ConnectTo(graph.Out(2));

  // Get `CalculatorGraphConfig` to pass it into `CalculatorGraph`
  return graph.GetConfig();
}

แม้ว่าการนำเสนอ pbtxt อาจเกิดข้อผิดพลาดขึ้น (เมื่อเรามีอินพุตจำนวนมากที่จะส่งผ่าน) แต่โค้ด C++ จะดูแย่กว่า: การใช้แท็กว่างซ้ำๆ และการเรียกใช้ Cast มาดูกันว่าเราจะทำให้ดีขึ้นได้อย่างไรด้วยการแนะนำ PassThroughNodeBuilder

class PassThroughNodeBuilder {
 public:
  explicit PassThroughNodeBuilder(Graph& graph)
      : node_(graph.AddNode("PassThroughCalculator")) {}

  template <typename T>
  Stream<T> PassThrough(Stream<T> stream) {
    stream.ConnectTo(node_.In(index_));
    return node_.Out(index_++).Cast<T>();
  }

 private:
  int index_ = 0;
  GenericNode& node_;
};

และตอนนี้โค้ดการสร้างกราฟอาจมีลักษณะดังนี้

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Graph inputs.
  Stream<float> float_value = graph.In(0).SetName("float_value").Cast<float>();
  Stream<int> int_value = graph.In(1).SetName("int_value").Cast<int>();
  Stream<bool> bool_value = graph.In(2).SetName("bool_value").Cast<bool>();

  PassThroughNodeBuilder pass_node_builder(graph);
  Stream<float> passed_float_value = pass_node_builder.PassThrough(float_value);
  Stream<int> passed_int_value = pass_node_builder.PassThrough(int_value);
  Stream<bool> passed_bool_value = pass_node_builder.PassThrough(bool_value);

  // Graph outputs.
  passed_float_value.SetName("passed_float_value").ConnectTo(graph.Out(0));
  passed_int_value.SetName("passed_int_value").ConnectTo(graph.Out(1));
  passed_bool_value.SetName("passed_bool_value").ConnectTo(graph.Out(2));

  // Get `CalculatorGraphConfig` to pass it into `CalculatorGraph`
  return graph.GetConfig();
}

ตอนนี้คุณต้องไม่มีลำดับหรือดัชนีที่ไม่ถูกต้องในโค้ดการก่อสร้างของการส่งผ่าน และบันทึกการพิมพ์โดยคาดเดาประเภทสำหรับ Cast จากอินพุต PassThrough

สิ่งที่ควรและไม่ควรทำ

กำหนดอินพุตกราฟตั้งแต่ช่วงต้นๆ หากเป็นไปได้

ในโค้ดด้านล่าง

• การเดาจำนวนอินพุตของคุณในกราฟอาจเป็นเรื่องยาก
• อาจเป็นข้อผิดพลาดที่อาจเกิดขึ้นโดยรวม และดูแลรักษายากในอนาคต (เช่น ดัชนีถูกต้องไหม ชื่ออะไร จะเกิดอะไรขึ้นหากอินพุตบางส่วนถูกนำออกหรือไม่บังคับ ฯลฯ)
• การนำ RunSomething มาใช้ซ้ำถูกจำกัดเนื่องจากกราฟอื่นๆ อาจมีอินพุตต่างกัน

ไม่ควรทำ — ตัวอย่างโค้ดที่ไม่ถูกต้อง

Stream<D> RunSomething(Stream<A> a, Stream<B> b, Graph& graph) {
  Stream<C> c = graph.In(2).SetName("c").Cast<C>();  // Bad.
  // ...
}

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  Stream<A> a = graph.In(0).SetName("a").Cast<A>();
  // 10/100/N lines of code.
  Stream<B> b = graph.In(1).SetName("b").Cast<B>()  // Bad.
  Stream<D> d = RunSomething(a, b, graph);
  // ...

  return graph.GetConfig();
}

แต่ให้กำหนดอินพุตกราฟที่จุดเริ่มต้นของเครื่องมือสร้างกราฟแทน ดังนี้

สิ่งที่ควรทำ — ตัวอย่างของโค้ดที่ดี

Stream<D> RunSomething(Stream<A> a, Stream<B> b, Stream<C> c, Graph& graph) {
  // ...
}

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Inputs.
  Stream<A> a = graph.In(0).SetName("a").Cast<A>();
  Stream<B> b = graph.In(1).SetName("b").Cast<B>();
  Stream<C> c = graph.In(2).SetName("c").Cast<C>();

  // 10/100/N lines of code.
  Stream<D> d = RunSomething(a, b, c, graph);
  // ...

  return graph.GetConfig();
}

ใช้ std::optional หากคุณมีสตรีมอินพุตหรือแพ็กเก็ตด้านข้างที่ไม่ได้กำหนดไว้เสมอและวางไว้ตั้งแต่แรกสุด ให้ทำดังนี้

สิ่งที่ควรทำ — ตัวอย่างของโค้ดที่ดี

std::optional<Stream<A>> a;
if (needs_a) {
  a = graph.In(0).SetName(a).Cast<A>();
}

กำหนดเอาต์พุตกราฟในตอนท้าย

ในโค้ดด้านล่าง

• การคาดเดาจำนวนเอาต์พุตในกราฟอาจเป็นเรื่องยาก
• อาจเป็นข้อผิดพลาดที่อาจเกิดขึ้นโดยรวมและดูแลรักษายากในอนาคต (เช่น ดัชนีถูกต้องไหม ชื่อจะเป็นอย่างไร หากมีการลบส่วนเกินออกหรือกำหนดให้ไม่บังคับ ฯลฯ)
• การนำ RunSomething มาใช้ซ้ำถูกจำกัดเนื่องจากกราฟอื่นๆ อาจมีเอาต์พุตต่างกัน

ไม่ควรทำ — ตัวอย่างโค้ดที่ไม่ถูกต้อง

void RunSomething(Stream<Input> input, Graph& graph) {
  // ...
  node.Out("OUTPUT_F")
      .SetName("output_f").ConnectTo(graph.Out(2));  // Bad.
}

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // 10/100/N lines of code.
  node.Out("OUTPUT_D")
      .SetName("output_d").ConnectTo(graph.Out(0));  // Bad.
  // 10/100/N lines of code.
  node.Out("OUTPUT_E")
      .SetName("output_e").ConnectTo(graph.Out(1));  // Bad.
  // 10/100/N lines of code.
  RunSomething(input, graph);
  // ...

  return graph.GetConfig();
}

ให้กำหนดเอาต์พุตกราฟที่ส่วนท้ายของเครื่องมือสร้างกราฟแทน ดังนี้

สิ่งที่ควรทำ — ตัวอย่างของโค้ดที่ดี

Stream<F> RunSomething(Stream<Input> input, Graph& graph) {
  // ...
  return node.Out("OUTPUT_F").Cast<F>();
}

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // 10/100/N lines of code.
  Stream<D> d = node.Out("OUTPUT_D").Cast<D>();
  // 10/100/N lines of code.
  Stream<E> e = node.Out("OUTPUT_E").Cast<E>();
  // 10/100/N lines of code.
  Stream<F> f = RunSomething(input, graph);
  // ...

  // Outputs.
  d.SetName("output_d").ConnectTo(graph.Out(0));
  e.SetName("output_e").ConnectTo(graph.Out(1));
  f.SetName("output_f").ConnectTo(graph.Out(2));

  return graph.GetConfig();
}

แยกโหนดออกจากกัน

ใน MediaPipe สตรีมแพ็กเก็ตและแพ็กเก็ตด้านข้างจะมีความหมายไม่ต่างจากโหนดในการประมวลผล และข้อกำหนดอินพุตโหนดและผลิตภัณฑ์เอาต์พุตก็จะแสดงอย่างชัดเจนและแยกเป็นอิสระจากกันในแง่ของสตรีมและแพ็กเก็ตไซด์ที่ใช้และผลิต

ไม่ควรทำ — ตัวอย่างโค้ดที่ไม่ถูกต้อง

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Inputs.
  Stream<A> a = graph.In(0).Cast<A>();

  auto& node1 = graph.AddNode("Calculator1");
  a.ConnectTo(node1.In("INPUT"));

  auto& node2 = graph.AddNode("Calculator2");
  node1.Out("OUTPUT").ConnectTo(node2.In("INPUT"));  // Bad.

  auto& node3 = graph.AddNode("Calculator3");
  node1.Out("OUTPUT").ConnectTo(node3.In("INPUT_B"));  // Bad.
  node2.Out("OUTPUT").ConnectTo(node3.In("INPUT_C"));  // Bad.

  auto& node4 = graph.AddNode("Calculator4");
  node1.Out("OUTPUT").ConnectTo(node4.In("INPUT_B"));  // Bad.
  node2.Out("OUTPUT").ConnectTo(node4.In("INPUT_C"));  // Bad.
  node3.Out("OUTPUT").ConnectTo(node4.In("INPUT_D"));  // Bad.

  // Outputs.
  node1.Out("OUTPUT").SetName("b").ConnectTo(graph.Out(0));  // Bad.
  node2.Out("OUTPUT").SetName("c").ConnectTo(graph.Out(1));  // Bad.
  node3.Out("OUTPUT").SetName("d").ConnectTo(graph.Out(2));  // Bad.
  node4.Out("OUTPUT").SetName("e").ConnectTo(graph.Out(3));  // Bad.

  return graph.GetConfig();
}

ในโค้ดด้านบน:

• โหนดจะเชื่อมโยงถึงกัน เช่น node4 รู้ว่าอินพุตมาจากที่ใด (node1, node2, node3) และทำให้เกิดความยุ่งยากในการปรับโครงสร้าง การบำรุงรักษา และการใช้โค้ดซ้ำ
  • รูปแบบการใช้งานดังกล่าวเป็นการดาวน์เกรดจากการแสดง Proto ซึ่งระบบจะแยกโหนดโดยค่าเริ่มต้น
• การเรียก node#.Out("OUTPUT") รายการซ้ำกันและมีความอ่านง่ายเพราะคุณอาจใช้ชื่อที่เรียบง่ายขึ้นแทน รวมถึงระบุประเภทจริงได้ด้วย

ดังนั้น เพื่อแก้ปัญหาข้างต้นนี้ คุณสามารถเขียนโค้ดการสร้างกราฟต่อไปนี้ได้

สิ่งที่ควรทำ — ตัวอย่างของโค้ดที่ดี

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Inputs.
  Stream<A> a = graph.In(0).Cast<A>();

  // `node1` usage is limited to 3 lines below.
  auto& node1 = graph.AddNode("Calculator1");
  a.ConnectTo(node1.In("INPUT"));
  Stream<B> b = node1.Out("OUTPUT").Cast<B>();

  // `node2` usage is limited to 3 lines below.
  auto& node2 = graph.AddNode("Calculator2");
  b.ConnectTo(node2.In("INPUT"));
  Stream<C> c = node2.Out("OUTPUT").Cast<C>();

  // `node3` usage is limited to 4 lines below.
  auto& node3 = graph.AddNode("Calculator3");
  b.ConnectTo(node3.In("INPUT_B"));
  c.ConnectTo(node3.In("INPUT_C"));
  Stream<D> d = node3.Out("OUTPUT").Cast<D>();

  // `node4` usage is limited to 5 lines below.
  auto& node4 = graph.AddNode("Calculator4");
  b.ConnectTo(node4.In("INPUT_B"));
  c.ConnectTo(node4.In("INPUT_C"));
  d.ConnectTo(node4.In("INPUT_D"));
  Stream<E> e = node4.Out("OUTPUT").Cast<E>();

  // Outputs.
  b.SetName("b").ConnectTo(graph.Out(0));
  c.SetName("c").ConnectTo(graph.Out(1));
  d.SetName("d").ConnectTo(graph.Out(2));
  e.SetName("e").ConnectTo(graph.Out(3));

  return graph.GetConfig();
}

ในตอนนี้ คุณสามารถนำ node1 ออกและทำให้ b เป็นอินพุตกราฟได้อย่างง่ายดาย โดยไม่ต้องอัปเดตสำหรับ node2, node3, node4 (เหมือนกับในการนำเสนอ Proto เลย) เพราะแยกออกจากกัน

โดยรวมแล้ว โค้ดข้างต้นจะจำลองกราฟโปรโตอย่างใกล้ชิดยิ่งขึ้น

input_stream: "a"

node {
  calculator: "Calculator1"
  input_stream: "INPUT:a"
  output_stream: "OUTPUT:b"
}

node {
  calculator: "Calculator2"
  input_stream: "INPUT:b"
  output_stream: "OUTPUT:C"
}

node {
  calculator: "Calculator3"
  input_stream: "INPUT_B:b"
  input_stream: "INPUT_C:c"
  output_stream: "OUTPUT:d"
}

node {
  calculator: "Calculator4"
  input_stream: "INPUT_B:b"
  input_stream: "INPUT_C:c"
  input_stream: "INPUT_D:d"
  output_stream: "OUTPUT:e"
}

output_stream: "b"
output_stream: "c"
output_stream: "d"
output_stream: "e"

ยิ่งไปกว่านั้น ตอนนี้คุณสามารถแยกฟังก์ชันยูทิลิตีเพื่อใช้ซ้ำในกราฟอื่นๆ ได้ด้วย

สิ่งที่ควรทำ — ตัวอย่างของโค้ดที่ดี

Stream<B> RunCalculator1(Stream<A> a, Graph& graph) {
  auto& node = graph.AddNode("Calculator1");
  a.ConnectTo(node.In("INPUT"));
  return node.Out("OUTPUT").Cast<B>();
}

Stream<C> RunCalculator2(Stream<B> b, Graph& graph) {
  auto& node = graph.AddNode("Calculator2");
  b.ConnectTo(node.In("INPUT"));
  return node.Out("OUTPUT").Cast<C>();
}

Stream<D> RunCalculator3(Stream<B> b, Stream<C> c, Graph& graph) {
  auto& node = graph.AddNode("Calculator3");
  b.ConnectTo(node.In("INPUT_B"));
  c.ConnectTo(node.In("INPUT_C"));
  return node.Out("OUTPUT").Cast<D>();
}

Stream<E> RunCalculator4(Stream<B> b, Stream<C> c, Stream<D> d, Graph& graph) {
  auto& node = graph.AddNode("Calculator4");
  b.ConnectTo(node.In("INPUT_B"));
  c.ConnectTo(node.In("INPUT_C"));
  d.ConnectTo(node.In("INPUT_D"));
  return node.Out("OUTPUT").Cast<E>();
}

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Inputs.
  Stream<A> a = graph.In(0).Cast<A>();

  Stream<B> b = RunCalculator1(a, graph);
  Stream<C> c = RunCalculator2(b, graph);
  Stream<D> d = RunCalculator3(b, c, graph);
  Stream<E> e = RunCalculator4(b, c, d, graph);

  // Outputs.
  b.SetName("b").ConnectTo(graph.Out(0));
  c.SetName("c").ConnectTo(graph.Out(1));
  d.SetName("d").ConnectTo(graph.Out(2));
  e.SetName("e").ConnectTo(graph.Out(3));

  return graph.GetConfig();
}

แยกโหนดเพื่อให้อ่านง่ายขึ้น

ไม่ควรทำ — ตัวอย่างโค้ดที่ไม่ถูกต้อง

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Inputs.
  Stream<A> a = graph.In(0).Cast<A>();
  auto& node1 = graph.AddNode("Calculator1");
  a.ConnectTo(node1.In("INPUT"));
  Stream<B> b = node1.Out("OUTPUT").Cast<B>();
  auto& node2 = graph.AddNode("Calculator2");
  b.ConnectTo(node2.In("INPUT"));
  Stream<C> c = node2.Out("OUTPUT").Cast<C>();
  auto& node3 = graph.AddNode("Calculator3");
  b.ConnectTo(node3.In("INPUT_B"));
  c.ConnectTo(node3.In("INPUT_C"));
  Stream<D> d = node3.Out("OUTPUT").Cast<D>();
  auto& node4 = graph.AddNode("Calculator4");
  b.ConnectTo(node4.In("INPUT_B"));
  c.ConnectTo(node4.In("INPUT_C"));
  d.ConnectTo(node4.In("INPUT_D"));
  Stream<E> e = node4.Out("OUTPUT").Cast<E>();
  // Outputs.
  b.SetName("b").ConnectTo(graph.Out(0));
  c.SetName("c").ConnectTo(graph.Out(1));
  d.SetName("d").ConnectTo(graph.Out(2));
  e.SetName("e").ConnectTo(graph.Out(3));

  return graph.GetConfig();
}

ในโค้ดข้างต้น ความเข้าใจว่าแต่ละโหนดเริ่มต้นและสิ้นสุดที่ใดอาจเป็นเรื่องยาก ในการปรับปรุงนี้และช่วยโปรแกรมอ่านโค้ด คุณสามารถเว้นบรรทัดว่างก่อนและหลังแต่ละโหนดได้ โดยทำดังนี้

สิ่งที่ควรทำ — ตัวอย่างของโค้ดที่ดี

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Inputs.
  Stream<A> a = graph.In(0).Cast<A>();

  auto& node1 = graph.AddNode("Calculator1");
  a.ConnectTo(node1.In("INPUT"));
  Stream<B> b = node1.Out("OUTPUT").Cast<B>();

  auto& node2 = graph.AddNode("Calculator2");
  b.ConnectTo(node2.In("INPUT"));
  Stream<C> c = node2.Out("OUTPUT").Cast<C>();

  auto& node3 = graph.AddNode("Calculator3");
  b.ConnectTo(node3.In("INPUT_B"));
  c.ConnectTo(node3.In("INPUT_C"));
  Stream<D> d = node3.Out("OUTPUT").Cast<D>();

  auto& node4 = graph.AddNode("Calculator4");
  b.ConnectTo(node4.In("INPUT_B"));
  c.ConnectTo(node4.In("INPUT_C"));
  d.ConnectTo(node4.In("INPUT_D"));
  Stream<E> e = node4.Out("OUTPUT").Cast<E>();

  // Outputs.
  b.SetName("b").ConnectTo(graph.Out(0));
  c.SetName("c").ConnectTo(graph.Out(1));
  d.SetName("d").ConnectTo(graph.Out(2));
  e.SetName("e").ConnectTo(graph.Out(3));

  return graph.GetConfig();
}

นอกจากนั้น ข้อมูลข้างต้นต้องตรงกับการนําเสนอโปรโต CalculatorGraphConfig มากกว่า

หากคุณแยกโหนดลงในฟังก์ชันยูทิลิตี โหนดเหล่านี้จะกำหนดขอบเขตไว้ภายในฟังก์ชันอยู่แล้วและเห็นได้ชัดว่าเริ่มต้นและสิ้นสุดที่ใด ดังนั้นคุณจะมีสิ่งต่อไปนี้ได้

สิ่งที่ควรทำ — ตัวอย่างของโค้ดที่ดี

CalculatorGraphConfig BuildGraph() {
  Graph graph;

  // Inputs.
  Stream<A> a = graph.In(0).Cast<A>();

  Stream<B> b = RunCalculator1(a, graph);
  Stream<C> c = RunCalculator2(b, graph);
  Stream<D> d = RunCalculator3(b, c, graph);
  Stream<E> e = RunCalculator4(b, c, d, graph);

  // Outputs.
  b.SetName("b").ConnectTo(graph.Out(0));
  c.SetName("c").ConnectTo(graph.Out(1));
  d.SetName("d").ConnectTo(graph.Out(2));
  e.SetName("e").ConnectTo(graph.Out(3));

  return graph.GetConfig();
}