בונה התרשימים 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();
}
במקום זאת, עליך להגדיר את נתוני הקלט של התרשים ממש בתחילת בונה התרשימים:
DO - דוגמה לקוד טוב.
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
אם יש לכם זרם קלט או מנת צד שלא תמיד מוגדרים, ושמים אותם בהתחלה:
DO - דוגמה לקוד טוב.
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();
}
במקום זאת, הגדירו את פלטי התרשים בסוף בונה התרשימים:
DO - דוגמה לקוד טוב.
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, לזרמי חבילות ולחבילות צד יש משמעות לא פחות מצומתי עיבוד. כמו כן, כל הדרישות לקלט של צמתים ותוצרי הפלט מבוטאות באופן ברור ובלתי תלוי במונחים של חבילות צד ו-streams שהם צורכים ומייצרים.
לא — דוגמה לקוד שגוי.
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
) והוא מורכב מארגון מחדש (Refactoring), תחזוקה ושימוש חוזר בקוד- דפוס שימוש כזה הוא שדרוג לאחור מייצוג פרוטו, שבו הצמתים מופרדים כברירת מחדל.
- קריאות
node#.Out("OUTPUT")
כפולות, וכתוצאה מכך הקריאות עלולות להיפגע כי אפשר להשתמש בשמות נקיים יותר וגם לציין את הסוג בפועל.
לכן, כדי לתקן את הבעיות שצוינו למעלה, אפשר לכתוב את הקוד הבא ליצירת גרף:
DO - דוגמה לקוד טוב.
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
(כמו בייצוג פרוטוגרפי, אגב), כי הם מופרדים אחד מהשני.
ככלל, הקוד שלמעלה מדמה את תרשים האב בצורה מדויקת יותר:
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"
בנוסף, עכשיו אפשר לחלץ פונקציות שימושיות לשימוש חוזר בגרפים אחרים:
DO - דוגמה לקוד טוב.
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();
}
בקוד שלמעלה, קשה להבין איפה כל צומת מתחיל ומסתיים. כדי לשפר את המצב ולעזור לקוראי הקוד שלכם, אתם יכולים פשוט להשאיר שורות ריקות לפני ואחרי כל צומת:
DO - דוגמה לקוד טוב.
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
.
אם מחלצים צמתים לפונקציות של תועלת, הם נמצאים בתוך הפונקציות שכבר קיימות וברור איפה הן מתחילות ומסתיימות, כך שזה בסדר גמור:
DO - דוגמה לקוד טוב.
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();
}