rename Continue to Run

nan2088 · nan2088 · commit b23ddcc711f3 · 2023-08-31T10:25:36.000+08:00
diff --git a/docs/Inter-node/filter.mdx b/docs/Inter-node/filter.mdx
@@ -5,12 +5,12 @@ type: explainer
 ---
 
 As introduced in [filter](../Intra-node/Sequential.mdx#filter_sequential) in Sequential, `filter` is a logical control instruction between nodes or backends, with the following states:
-Continue, Skip, SerialSkip, SubGraphSkip, Break, Error.
+Run, Skip, SerialSkip, SubGraphSkip, Break, Error.
 
 ## Default Multi-Node Scheduler Interpretation of `filter` Return Values
 
 In multi-node scheduling, the return values of `filter` represent:
-- `Continue`: the backend of the current node can be executed.
+- `Run`: the backend of the current node can be executed.
 - `Skip`: the backend of the current node can be skipped, but it does not mean that the node has no result. The result of the node is the `dict` processed by `filter`.
 - `Break`: the execution of the entire DAG is terminated, and the `dict` processed by `filter` is the final result.
 - `Error`: an error occurred.
@@ -62,7 +62,7 @@ class your_filter : public Filter {
     // highlight-next-line
         return status::SubGraphSkip;
     else
-        return status::Continue;     
+        return status::Run;     
     }
 };
 IPIPE_REGISTER(Filter, your_filter, "your_filter");
@@ -77,11 +77,11 @@ filter="your_filter"
 Please do not use the same name as built-in filters for custom filters.
 
 ## Built-in Filters {#default_filters}
-|                                                                                                                                                          | Function                                                            |   |
-|----------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------|---|
-| Continue/run <br />Skip/skip <br />SerialSkip/serial_skip/serialskip <br />SubGraphSkip/subgraph_skip/subgraphskip, <br />Break/break, <br />Error/error | Returns the corresponding status value unconditionally              |   |
-| swap                                                                                                                                                     | Returns `Break` if there is no result, otherwise returns `Continue` |   |
-| or                                                                                                                                                       | Returns `Continue` if there is no result, otherwise returns `Skip`  |   |
+|                                                                                                                                                     | Function                                                       |   |
+|-----------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------|---|
+| Run/run <br />Skip/skip <br />SerialSkip/serial_skip/serialskip <br />SubGraphSkip/subgraph_skip/subgraphskip, <br />Break/break, <br />Error/error | Returns the corresponding status value unconditionally         |   |
+| swap                                                                                                                                                | Returns `Break` if there is no result, otherwise returns `Run` |   |
+| or                                                                                                                                                  | Returns `Run` if there is no result, otherwise returns `Skip`  |   |
 
 
 
diff --git a/docs/Inter-node/next.mdx b/docs/Inter-node/next.mdx
@@ -30,7 +30,7 @@ next="resize"
 
 The `decode->resize` forms a directed acyclic graph consisting of two nodes, where `decode` is the root node and `resize` is the child node.
 
-Similar to `Sequential`, the root node defaults to [filter](../Intra-node/Sequential.mdx#filter_sequential) = `Continue`, and the child node defaults to filter = `swap`.
+Similar to `Sequential`, the root node defaults to [filter](../Intra-node/Sequential.mdx#filter_sequential) = `Run`, and the child node defaults to filter = `swap`.
 
 :::info Data Flow
 The original input `dict` data enters the `decode` node, and its `result` key value is written into the result.
@@ -76,7 +76,7 @@ The original input `dict` data is processed by node `A`, and both nodes `B` and
 # highlight-next-line
 map="B[result:B_result],C[result:data]"
 ```
-The `output` configuration uses `map` to map the `result` of node B to its own `B_result`, and the `result` of node C to `data`. When `map` is present, the default filter is `Continue/run`, which means that no further processing is done on the input data.
+The `output` configuration uses `map` to map the `result` of node B to its own `B_result`, and the `result` of node C to `data`. When `map` is present, the default filter is `Run/run`, which means that no further processing is done on the input data.
 
 `map` can also map multiple key-value pairs from preceding nodes to itself, such as `map="B[1:0,1:1,2:data]"`.
 
diff --git a/docs/Intra-node/Sequential.mdx b/docs/Intra-node/Sequential.mdx
@@ -19,10 +19,10 @@ During the forward execution of `Sequential[DecodeMat,ResizeMat]`, the data (dic
 
 `Sequential` can be abbreviated as `S`. API reference can be found in [`Sequential`](../backend-reference/basic#sequential).
 ## Conditional Control Flow Filter {#filter_sequential}
-`Sequential` itself implements support for control flow syntax extensions. In fact, `S[DecodeMat,ResizeMat]` is equivalent to `S[(Continue)DecodeMat,(swap)ResizeMat]`.
+`Sequential` itself implements support for control flow syntax extensions. In fact, `S[DecodeMat,ResizeMat]` is equivalent to `S[(Run)DecodeMat,(swap)ResizeMat]`.
 
 The filters in `()` parentheses can return the following states:
-- Continue, which means that the current sub-backend can be skipped and wait to enter the next sub-backend (renamed to Run since version 0.3.2)
+- Run, which means that the current sub-backend can be skipped and wait to enter the next sub-backend (Effective from v0.3.2b1; `Continue` can be used in previous versions.)
 - Break, which means to exit the execution of `Sequential`
 - Error, which means an error occurred
 - SerialSkip, which means that consecutive serial sub-backends can be skipped, equivalent to Break in `Sequential`
@@ -31,16 +31,16 @@ The filters in `()` parentheses can return the following states:
 Here are some built-in filter definitions:
 
 <Tabs groupId="filter"  className="unique-tabs">
-<TabItem value="Continue" label="Continue">
+<TabItem value="Run" label="Run">
 
 ```cpp
 #include "filter.hpp"
 
-class FilterContinue : public Filter {
+class FilterRun : public Filter {
  public:
-  status forward(dict data) override { return Filter::status::Continue; }
+  status forward(dict data) override { return Filter::status::Run; }
 };
-IPIPE_REGISTER(Filter, FilterContinue, "Continue,run");
+IPIPE_REGISTER(Filter, FilterRun, "Run,run");
 ```
 
 
@@ -50,7 +50,7 @@ IPIPE_REGISTER(Filter, FilterContinue, "Continue,run");
 ```cpp
 class Filter {
  public:
-  enum struct status { Continue, Skip, SerialSkip, SubGraphSkip, Break, Error };
+  enum struct status { Run, Skip, SerialSkip, SubGraphSkip, Break, Error };
 
   virtual bool init(const std::unordered_map<std::string, std::string>& /*config*/,
                     dict /*dict_config*/) {
@@ -65,7 +65,7 @@ class Filter {
 
     (*input)[TASK_DATA_KEY] = (*input)[TASK_RESULT_KEY];
     input->erase(iter);
-    return status::Continue;
+    return status::Run;
   }
 
   virtual ~Filter() = default;
@@ -80,7 +80,7 @@ Based on this, as will be discussed in the next section on [extending and compil
 Suppose there is a backend `S[DecodeTensor,(swap)TensorrtTensor,TensorrtSync]`, where the input range of `DecodeTensor` is [1,1], and the range of `TensorrtTensor` is [1,4]. According to the [Sequential rule for calculating input range](../backend-reference/basic#sequential), the input range of Sequential is [1,4].
 
 If four data enter this Sequential at the same time, but one of them fails to decode, then
-- One data returns `status::Break` in `swap`, while the others return `status::Continue`.
+- One data returns `status::Break` in `swap`, while the others return `status::Run`.
 - `Sequential` continues to send the remaining three data to the next stage, while the data in `Break` state terminates the execution in Sequential.
 
 The above describes the response when encountering `Break` for some data; similarly, when encountering `Skip` for some data, the data will be locally processed in a similar way. However, when a data is in `Error` state, Sequential will consider the overall task status as `Error`. If this contradicts the user's intention, the user can try to split the sub-backends into different Sequentials to avoid mutual interference. Note that the `Error` state is generally extremely rare and unexpected. 
diff --git a/docs/faq/onnx.mdx b/docs/faq/onnx.mdx
@@ -47,11 +47,11 @@ At this point, it is recommended to **discretize only one dimension**.
 After modifying the network, you can use the following code to convert the PyTorch model to an ONNX model:
 
 ```python
-x = torch.randn(1,*input_shape).cuda()
+x = torch.randn(1,3,224,224).cuda()
 out_size = 1
-out={"input":{0:"batch_size"}}
+in_out={"input":{0:"batch_size"}}
 for i in range(out_size):
-    out[f"output_{i}"] = {0:"batch_size"}
+    in_out[f"output_{i}"] = {0:"batch_size"}
 
 torch_model.cuda().eval()
 torch.onnx.export(torch_model,
@@ -61,7 +61,7 @@ torch.onnx.export(torch_model,
                     do_constant_folding=True,	
                     input_names=["input"],		# input name
                     output_names=[f"output_{i}" for i in range(out_size)],	# output names
-                    dynamic_axes=out)
+                    dynamic_axes=in_out)
 
 import onnx
 from onnxsim import onnx_simplifier
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/Inter-node/filter.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/Inter-node/filter.mdx
@@ -5,12 +5,12 @@ type: explainer
 ---
 
 正如在Sequential引入[filter](../Intra-node/Sequential.mdx#filter_sequential)时介绍过的，filter是节点或者后端间的逻辑控制指令，拥有以下状态：
-Continue, Skip, SerialSkip, SubGraphSkip, Break, Error.
+Run, Skip, SerialSkip, SubGraphSkip, Break, Error.
 
 ## 默认多节点调度器对filter返回值的解析
 
 在多节点调度中，filter返回值分别代表：
-- Continue, 代表可以执行当前节点的后端
+- Run, 代表可以执行当前节点的后端
 - Skip, 代表跳过当前节点的后端，但是不代表这个节点没有结果。节点的结果就是被filter处理过的`dict`
 - Break, 代表跳出整个有向无环图的执行， 被filter处理过的`dict`就是最终结果
 - Error, 代表出现错误
@@ -62,7 +62,7 @@ class your_filter : public Filter {
     // highlight-next-line
         return status::SubGraphSkip;
     else
-        return status::Continue;     
+        return status::Run;     
     }
 };
 IPIPE_REGISTER(Filter, your_filter, "your_filter");
@@ -77,11 +77,11 @@ filter="your_filter"
 
 注意自定义filter请勿与内置filter重名。
 ## 内置filter {#default_filters}
-|                                                                                                                                                          | 功能                                  |   |
-|----------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------|---|
-| Continue/run <br />Skip/skip <br />SerialSkip/serial_skip/serialskip <br />SubGraphSkip/subgraph_skip/subgraphskip, <br />Break/break, <br />Error/error | 无条件返回对应状态值                  |   |
-| swap                                                                                                                                                     | 没有result返回Break, 否则返回Continue |   |
-| or                                                                                                                                                       | 没有result返回Continue, 否则返回Skip  |   |
+|                                                                                                                                                     | 功能                             |   |
+|-----------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------|---|
+| Run/run <br />Skip/skip <br />SerialSkip/serial_skip/serialskip <br />SubGraphSkip/subgraph_skip/subgraphskip, <br />Break/break, <br />Error/error | 无条件返回对应状态值             |   |
+| swap                                                                                                                                                | 没有result返回Break, 否则返回Run |   |
+| or                                                                                                                                                  | 没有result返回Run, 否则返回Skip  |   |
 
 
 
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/Inter-node/next.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/Inter-node/next.mdx
@@ -27,7 +27,7 @@ next="resize"
 
 `decode->resize`组成了由两个节点构成的有向无环图，其中decode是根节点，resize是子节点。
 
-与Sequential类似，根节点默认[filter](../Intra-node/Sequential.mdx#filter_sequential)=`Continue`, 子节点默认filter=`swap`.
+与Sequential类似，根节点默认[filter](../Intra-node/Sequential.mdx#filter_sequential)=`Run`, 子节点默认filter=`swap`.
 
 :::info 数据流向
 原始输入`dict`数据进入节点`decode`后，它的`result`键值被写入了结果。
@@ -75,7 +75,7 @@ next="output"
 map="B[result:B_result],C[result:data]"
 ```
 
-output通过`map`配置将B节点的result映射到了自己的B_result， 将C节点的result映射到了data. 当map存在时，默认filter为`Continue/run`, 也就是不再对输入数据做任何处理。
+output通过`map`配置将B节点的result映射到了自己的B_result， 将C节点的result映射到了data. 当map存在时，默认filter为`Run/run`, 也就是不再对输入数据做任何处理。
 
 `map`亦可将前序节点的多个键值映射到自身，如 `map="B[1:0,1:1,2:data]"`
 
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/Intra-node/Sequential.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/Intra-node/Sequential.mdx
@@ -21,10 +21,10 @@ import TabItem from '@theme/TabItem';
 `Sequential`可简写为`S`. API可参考[`Sequential`](../backend-reference/basic#sequential).
 
 ## 条件控制流 filter {#filter_sequential}
-`Sequential` 这个后端本身实现了对控制流语法扩展的支持。事实上，`S[DecodeMat,ResizeMat]` 等价于`S[(Continue)DecodeMat,(swap)ResizeMat]`.
+`Sequential` 这个后端本身实现了对控制流语法扩展的支持。事实上，`S[DecodeMat,ResizeMat]` 等价于`S[(Run)DecodeMat,(swap)ResizeMat]`.
 
 `()`括号内的filter可返回以下状态：
-- Continue, 代表可以跳过当前子后端，等待进入下一个子后端 
+- Run, 代表可以跳过当前子后端，等待进入下一个子后端(从0.3.2b1开始生效；之前版本可使用Continue)
 - Break, 代表跳出Sequential的执行 
 - Error, 代表出现错误
 - SerialSkip, 代表可以连续跳过串行子后端，在`Sequential`中，等价于Break
@@ -34,16 +34,16 @@ import TabItem from '@theme/TabItem';
 
 
 <Tabs groupId="filter"  className="unique-tabs">
-<TabItem value="Continue" label="Continue">
+<TabItem value="Run" label="Run">
 
 ```cpp
 #include "filter.hpp"
 
-class FilterContinue : public Filter {
+class FilterRun : public Filter {
  public:
-  status forward(dict data) override { return Filter::status::Continue; }
+  status forward(dict data) override { return Filter::status::Run; }
 };
-IPIPE_REGISTER(Filter, FilterContinue, "Continue,run");
+IPIPE_REGISTER(Filter, FilterRun, "Run,run");
 ```
 
 
@@ -53,7 +53,7 @@ IPIPE_REGISTER(Filter, FilterContinue, "Continue,run");
 ```cpp
 class Filter {
  public:
-  enum struct status { Continue, Skip, SerialSkip, SubGraphSkip, Break, Error };
+  enum struct status { Run, Skip, SerialSkip, SubGraphSkip, Break, Error };
 
   virtual bool init(const std::unordered_map<std::string, std::string>& /*config*/,
                     dict /*dict_config*/) {
@@ -68,7 +68,7 @@ class Filter {
 
     (*input)[TASK_DATA_KEY] = (*input)[TASK_RESULT_KEY];
     input->erase(iter);
-    return status::Continue;
+    return status::Run;
   }
 
   virtual ~Filter() = default;
@@ -86,7 +86,7 @@ class Filter {
 而`TensorrtTensor`的范围刚好是[1,4]. 根据[Sequential计算输入范围的规则](../backend-reference/basic#sequential)，Sequential的输入范围是[1,4].
 
 如果同时有四个数据进入此Sequential，但是其中一个解码失败，那么此时
-- 一个数据在`swap`中返回`status::Break`，其余返回`status::Continue`.
+- 一个数据在`swap`中返回`status::Break`，其余返回`status::Run`.
 - `Sequential`将三个数据继续送入下一个阶段, 而`Break`状态的数据终止Sequential中的执行
 
 以上是遇到部分数据`Break`时的反应；类似的，遇到部分数据`Skip`，也会类似地局部性处理数据。然而，当一个数据`Error`时，Sequential会认为任务整体的状态是`Error`. 如果这与使用者的本意相违背，使用者可以尝试将子后端拆分到不同的Sequential中，以避免互相影响。注意，`Error`状态一般是极其稀有的，预料外的状态。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/faq/onnx.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/faq/onnx.mdx
@@ -48,11 +48,11 @@ type: explainer
 修改完网络后，可以利用下面代码，将pytorch模型转换为onnx模型。
 
 ```python
-x = torch.randn(1,*input_shape).cuda()
+x = torch.randn(1,3,224,224).cuda()
 out_size = 1
-out={"input":{0:"batch_size"}}
+in_out={"input":{0:"batch_size"}}
 for i in range(out_size):
-    out[f"output_{i}"] = {0:"batch_size"}
+    in_out[f"output_{i}"] = {0:"batch_size"}
 
 torch_model.cuda().eval()
 torch.onnx.export(torch_model,
@@ -62,7 +62,7 @@ torch.onnx.export(torch_model,
                     do_constant_folding=True,	
                     input_names=["input"],		# 输入名
                     output_names=[f"output_{i}" for i in range(out_size)],	# 输出名
-                    dynamic_axes=out)
+                    dynamic_axes=in_out)
 
 import onnx
 from onnxsim import onnx_simplifier
