dflow入门5——Big step & Big parameter

为了梳理学习dflow时遇到的知识点，我决定开这一个系列记录自己的学习过程。当然了，最好是去看 官方教程 和 文档
本文，我们将讨论dflow的两个feature，big step 和 big parameter

big step

事实上，我们在上一节已经涉及到了Steps的一些用法
具体来说，他可以做循环、步骤重用和条件判断等等
事实上，steps还有一个潜在的用法，就是打包小的templates，实现模块化
我们来看test_big_parameter.py

import time

from dflow import InputParameter, OutputParameter, Step, Steps, Workflow
from dflow.python import (OP, OPIO, BigParameter, OPIOSign, PythonOPTemplate,
                          upload_packages)

if "__file__" in locals():
    upload_packages.append(__file__)


class Hello:
    def __init__(self, msg):
        self.msg = msg


class Duplicate(OP):
    def __init__(self):
        pass

    @classmethod
    def get_input_sign(cls):
        return OPIOSign({
            'foo': BigParameter(Hello)
        })

    @classmethod
    def get_output_sign(cls):
        return OPIOSign({
            'foo': BigParameter(Hello)
        })

    @OP.exec_sign_check
    def execute(
            self,
            op_in: OPIO,
    ) -> OPIO:
        foo = op_in["foo"]
        print(foo.msg)
        foo.msg = foo.msg * 2
        op_out = OPIO({
            "foo": foo
        })
        return op_out

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

首先定义了template，接收一个自定义参数，然后做一些操作

    wf = Workflow(name="big-param")

    steps = Steps(name="hello-steps")
    steps.inputs.parameters["foo"] = InputParameter()
    steps.outputs.parameters["foo"] = OutputParameter()

    step1 = Step(
        name="step1",
        template=PythonOPTemplate(Duplicate, image="python:3.8"),
        parameters={"foo": steps.inputs.parameters["foo"]},
        key="step1"
    )
    steps.add(step1)

    step2 = Step(
        name="step2",
        template=PythonOPTemplate(Duplicate, image="python:3.8"),
        parameters={"foo": step1.outputs.parameters["foo"]},
        key="step2"
    )
    steps.add(step2)

    steps.outputs.parameters["foo"].value_from_parameter = \
        step2.outputs.parameters["foo"]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

随后定义了空的steps，两个子的step串联，再压到steps里面，最后把steps的输出定向为最后一个串联模块的输出
下面一句是它的初始化

    big_step = Step(name="big-step", template=steps,
                    parameters={"foo": Hello("hello")})
1
2

可以看到，big step 的初始化和普通的小step的初始化基本一致，区别在于template的参数不再是PythonOPTemplate，因为steps本身就是一个OP，直接继承了OP，和PythonOPTemplate是等价的
因此，big step 完全可以当做一个 step 去使用！！
这将有利于我们构建更长、更复杂的工作流

Big parameter

上面的例子已经提到了。Big parameter 是自定义的参数，可以丰富变量类型。让OP跟普通python函数的接轨更加顺滑。