def run_workflow():
build_workflow()
af.set_project_config_file(project_path + '/project.yaml')
res = af.run(project_path,
dag_id='repeated_dag_example',
scheduler_type=SchedulerType.AIFLOW)
af.wait_workflow_execution_finished(res)
def run_project(project_root_path):
af.set_project_config_file(project_root_path + '/project.yaml')
# Config command line job, we set platform to local and engine to cmd_line here
cmd_job_config = af.BaseJobConfig(platform=LocalPlatform.platform(), engine=CMDEngine().engine())
with af.config(cmd_job_config):
# Command line job executor
cmd_job = af.user_define_operation(executor=CmdExecutor(cmd_line="echo Start AI flow"))
# Config python job, we set platform to local and engine to python here
python_job_config = af.BaseJobConfig(platform=LocalPlatform.platform(), engine=PythonEngine.engine())
# Set execution mode of this python job to BATCH,
# which indicates jobs with this config is running in the form of batch.
python_job_config.exec_mode = af.ExecutionMode.BATCH
with af.config(python_job_config):
# Path of Source data(under '..../simple_transform_airflow' dir)
source_path = os.path.dirname(os.path.abspath(__file__)) + '/source_data.csv'
# Path of Sink data
sink_path = os.path.dirname(os.path.abspath(__file__)) + '/sink_data.csv'
# To make the project replaceable, we register the example in metadata service
read_example_meta = af.register_example(name='read_example', support_type=ExampleSupportType.EXAMPLE_BATCH,
data_format='csv', data_type='pandas', batch_uri=source_path)
# Read training example using af.read_example()
# example_info is the meta information of the example
read_example_channel = af.read_example(example_info=read_example_meta, exec_args=ExecuteArgs(
batch_properties=Args(header=None, names=["a", "b", "c"])))
# Transform examples using af.transform()
transform_channel = af.transform(input_data_list=[read_example_channel],
executor=PythonObjectExecutor(python_object=SimpleTransform()))
write_example_meta = af.register_example(name='write_example', support_type=ExampleSupportType.EXAMPLE_BATCH,
data_format='csv', data_type='pandas', batch_uri=sink_path)
# Write example to specific path
write = af.write_example(input_data=transform_channel, example_info=write_example_meta,
exec_args=ExecuteArgs(batch_properties=Args(sep=',', header=False, index=False)))
# Add control dependency, which means read_example job will start right after command line job finishes.
af.stop_before_control_dependency(read_example_channel, cmd_job)
transform_dag = 'simple_transform'
af.deploy_to_airflow(project_root_path, dag_id=transform_dag)
context = af.run(project_path=project_root_path,
dag_id=transform_dag,
scheduler_type=SchedulerType.AIRFLOW)
def run_workflow():
build_workflow()
af.set_project_config_file(project_path + '/project.yaml')
# deploy a workflow which should be scheduled every 10 minutes
default_args = '{\'schedule_interval\': %s, \'start_date\': \'%s\'}' % (
'\'*/10 * * * *\'', datetime.utcnow())
af.deploy_to_airflow(project_path,
dag_id='airflow_dag_example',
default_args=default_args)
# Force trigger once
context = af.run(project_path=project_path,
dag_id='airflow_dag_example',
scheduler_type=SchedulerType.AIRFLOW)
print(context.dagrun_id)
def test_run_pyflink_job(self):
project_path = os.path.dirname(__file__) + '/../'
af.set_project_config_file(project_path + "project.yaml")
input_file = get_parent_dir(
get_file_dir(__file__)) + '/resources/word_count.txt'
output_file = get_file_dir(__file__) + "/word_count_output.csv"
if os.path.exists(output_file):
os.remove(output_file)
example_1 = af.create_example(
name="example_1",
support_type=af.ExampleSupportType.EXAMPLE_BOTH,
batch_uri=input_file,
stream_uri=input_file,
data_format="csv")
example_2 = af.create_example(
name="example_2",
support_type=af.ExampleSupportType.EXAMPLE_BOTH,
batch_uri=output_file,
stream_uri=output_file,
data_format="csv")
flink_config = faf.LocalFlinkJobConfig()
flink_config.local_mode = 'cluster'
flink_config.flink_home = '/Users/chenwuchao/soft/apache/flink-1.11.0/'
flink_config.set_table_env_create_func(TableEnvCreator())
with af.config(flink_config):
input_example = af.read_example(
example_info=example_1,
executor=faf.flink_executor.FlinkPythonExecutor(
python_object=Source()))
processed = af.transform(
input_data_list=[input_example],
executor=faf.flink_executor.FlinkPythonExecutor(
python_object=Transformer()))
af.write_example(input_data=processed,
example_info=example_2,
executor=faf.flink_executor.FlinkPythonExecutor(
python_object=Sink()))
workflow_id = af.run(project_path)
res = af.wait_workflow_execution_finished(workflow_id)
def run_project(project_root_path):
af.set_project_config_file(project_root_path + "/project.yaml")
project_name = af.project_config().get_project_name()
artifact_prefix = project_name + "."
validate_trigger = af.external_trigger(name='validate')
push_trigger = af.external_trigger(name='push')
with af.global_config_file(project_root_path + '/resources/workflow_config.yaml'):
with af.config('train_job'):
train_example = af.register_example(name=artifact_prefix + 'train_example',
support_type=ExampleSupportType.EXAMPLE_STREAM,
stream_uri=EXAMPLE_URI.format('train'))
train_read_example = af.read_example(example_info=train_example,
executor=PythonObjectExecutor(python_object=TrainExampleReader()))
train_transform = af.transform(input_data_list=[train_read_example],
executor=PythonObjectExecutor(python_object=TrainExampleTransformer()))
train_model = af.register_model(model_name=artifact_prefix + 'logistic-regression',
model_type=ModelType.SAVED_MODEL,
model_desc='logistic regression model')
train_channel = af.train(input_data_list=[train_transform],
executor=PythonObjectExecutor(python_object=ModelTrainer()),
model_info=train_model)
with af.config('validate_job'):
validate_example = af.register_example(name=artifact_prefix + 'validate_example',
support_type=ExampleSupportType.EXAMPLE_STREAM,
stream_uri=EXAMPLE_URI.format('evaluate'),
data_format='npz')
validate_read_example = af.read_example(example_info=validate_example,
executor=PythonObjectExecutor(
python_object=ValidateExampleReader()))
validate_transform = af.transform(input_data_list=[validate_read_example],
executor=PythonObjectExecutor(python_object=ValidateTransformer()))
validate_artifact_name = artifact_prefix + 'validate_artifact'
validate_artifact = af.register_artifact(name=validate_artifact_name,
stream_uri=get_file_dir(__file__) + '/validate_result')
validate_channel = af.model_validate(input_data_list=[validate_transform],
model_info=train_model,
executor=PythonObjectExecutor(
python_object=ModelValidator(validate_artifact_name)),
)
with af.config('push_job'):
# Push model to serving
# Register metadata of pushed model
push_model_artifact_name = artifact_prefix + 'push_model_artifact'
push_model_artifact = af.register_artifact(name=push_model_artifact_name,
stream_uri=get_file_dir(__file__) + '/pushed_model')
push_channel = af.push_model(model_info=train_model,
executor=PythonObjectExecutor(
python_object=ModelPusher(push_model_artifact_name)))
with af.config('predict_job'):
predict_example = af.register_example(name=artifact_prefix + 'predict_example',
support_type=ExampleSupportType.EXAMPLE_STREAM,
stream_uri=EXAMPLE_URI.format('predict'))
predict_read_example = af.read_example(example_info=predict_example,
executor=PythonObjectExecutor(python_object=PredictExampleReader()))
predict_transform = af.transform(input_data_list=[predict_read_example],
executor=PythonObjectExecutor(python_object=PredictTransformer()))
predict_channel = af.predict(input_data_list=[predict_transform],
model_info=train_model,
executor=PythonObjectExecutor(python_object=ModelPredictor()))
write_example = af.register_example(name=artifact_prefix + 'export_example',
support_type=ExampleSupportType.EXAMPLE_STREAM,
stream_uri=get_file_dir(__file__) + '/predict_result')
af.write_example(input_data=predict_channel,
example_info=write_example,
executor=PythonObjectExecutor(python_object=ExampleWriter()))
af.model_version_control_dependency(src=validate_channel,
model_version_event_type=ModelVersionEventType.MODEL_GENERATED,
dependency=validate_trigger, model_name=train_model.name)
af.model_version_control_dependency(src=push_channel,
model_version_event_type=ModelVersionEventType.MODEL_VALIDATED,
dependency=push_trigger, model_name=train_model.name)
# Run workflow
transform_dag = project_name
af.deploy_to_airflow(project_root_path, dag_id=transform_dag)
af.run(project_path=project_root_path,
dag_id=transform_dag,
scheduler_type=SchedulerType.AIRFLOW)
def run_project(project_root_path):
af.set_project_config_file(project_root_path + "/project.yaml")
project_name = af.project_config().get_project_name()
artifact_prefix = project_name + "."
validate_trigger = af.external_trigger(name='validate')
push_trigger = af.external_trigger(name='push')
with af.global_config_file(project_root_path + '/resources/workflow_config.yaml'):
# the config of train job is a periodic job which means it will
# run every `interval`(defined in workflow_config.yaml) seconds
with af.config('train_job'):
# Register metadata raw training data(example) and read example(i.e. training dataset)
train_example = af.register_example(name=artifact_prefix + 'train_example',
support_type=ExampleSupportType.EXAMPLE_BATCH,
batch_uri=EXAMPLE_URI.format('train'))
train_read_example = af.read_example(example_info=train_example,
executor=PythonObjectExecutor(python_object=ExampleReader()))
# Transform(preprocessing) example
train_transform = af.transform(input_data_list=[train_read_example],
executor=PythonObjectExecutor(python_object=ExampleTransformer()))
# Register model metadata and train model
train_model = af.register_model(model_name=artifact_prefix + 'logistic-regression',
model_type=ModelType.SAVED_MODEL,
model_desc='logistic regression model')
train_channel = af.train(input_data_list=[train_transform],
executor=PythonObjectExecutor(python_object=ModelTrainer()),
model_info=train_model)
with af.config('validate_job'):
# Validation of model
# Read validation dataset and validate model before it is used to predict
validate_example = af.register_example(name=artifact_prefix + 'validate_example',
support_type=ExampleSupportType.EXAMPLE_STREAM,
batch_uri=EXAMPLE_URI.format('evaluate'))
validate_read_example = af.read_example(example_info=validate_example,
executor=PythonObjectExecutor(
python_object=ValidateExampleReader()))
validate_transform = af.transform(input_data_list=[validate_read_example],
executor=PythonObjectExecutor(python_object=ValidateTransformer()))
validate_artifact_name = artifact_prefix + 'validate_artifact'
validate_artifact = af.register_artifact(name=validate_artifact_name,
batch_uri=get_file_dir(__file__) + '/validate_result')
validate_channel = af.model_validate(input_data_list=[validate_transform],
model_info=train_model,
executor=PythonObjectExecutor(
python_object=ModelValidator(validate_artifact_name)))
with af.config('push_job'):
# Push model to serving
# Register metadata of pushed model
push_model_artifact_name = artifact_prefix + 'push_model_artifact'
push_model_artifact = af.register_artifact(name=push_model_artifact_name,
batch_uri=get_file_dir(__file__) + '/pushed_model')
push_channel = af.push_model(model_info=train_model,
executor=PythonObjectExecutor(
python_object=ModelPusher(push_model_artifact_name)))
with af.config('predict_job'):
# Prediction(Inference)
predict_example = af.register_example(name=artifact_prefix + 'predict_example',
support_type=ExampleSupportType.EXAMPLE_STREAM,
stream_uri=EXAMPLE_URI.format('predict'))
predict_read_example = af.read_example(example_info=predict_example,
executor=PythonObjectExecutor(python_object=PredictExampleReader()))
predict_transform = af.transform(input_data_list=[predict_read_example],
executor=PythonObjectExecutor(python_object=PredictTransformer()))
predict_channel = af.predict(input_data_list=[predict_transform],
model_info=train_model,
executor=PythonObjectExecutor(python_object=ModelPredictor()))
# Save prediction result
write_example = af.register_example(name=artifact_prefix + 'write_example',
support_type=ExampleSupportType.EXAMPLE_STREAM,
stream_uri=get_file_dir(__file__) + '/predict_result')
af.write_example(input_data=predict_channel,
example_info=write_example,
executor=PythonObjectExecutor(python_object=ExampleWriter()))
# Define relation graph connected by control edge:
# Once a round of training is done, validator will be launched and
# pusher will be launched if the new model is better.
# Prediction will start once the first round of training is done and
# when pusher pushes(deploys) a new model, the predictor will use the latest deployed model as well.
af.model_version_control_dependency(src=validate_channel,
model_version_event_type=ModelVersionEventType.MODEL_GENERATED,
dependency=validate_trigger, model_name=train_model.name)
af.model_version_control_dependency(src=push_channel,
model_version_event_type=ModelVersionEventType.MODEL_VALIDATED,
dependency=push_trigger, model_name=train_model.name)
# Run workflow
transform_dag = project_name
af.deploy_to_airflow(project_root_path, dag_id=transform_dag)
af.run(project_path=project_root_path,
dag_id=transform_dag,
scheduler_type=SchedulerType.AIRFLOW)
executor=FlinkPythonExecutor(python_object=SearchSink()))
with af.config(global_job_config_4):
flink_job_3_read_online_example = af.read_example(example_info=second_test_example_meta,
executor=FlinkPythonExecutor(
python_object=ReadOnlinePredictExample()))
flink_job_3_predict_model = af.predict(input_data_list=[flink_job_3_read_online_example],
model_info=train_model_meta,
executor=FlinkPythonExecutor(python_object=OnlinePredictAutoEncoder()))
flink_job_3_transformed_data = af.transform([flink_job_3_predict_model],
executor=FlinkPythonExecutor(
python_object=SearchExecutor3(index_path, FloatDataType(), 2)))
af.write_example(input_data=flink_job_3_transformed_data,
example_info=second_result_example_meta,
executor=FlinkPythonExecutor(python_object=WriteSecondResult()))
af.stop_before_control_dependency(python_job_1_cluster_serving_channel, python_job_0_train_model)
af.stop_before_control_dependency(flink_job_0_read_train_example, python_job_1_cluster_serving_channel)
af.stop_before_control_dependency(python_job_2_merge_train_data_file, flink_job_0_read_train_example)
af.stop_before_control_dependency(flink_job_1_build_index_channel, python_job_2_merge_train_data_file)
af.stop_before_control_dependency(flink_job_2_read_history_example, flink_job_1_build_index_channel)
af.stop_before_control_dependency(flink_job_3_read_online_example, flink_job_2_write_result)
workflow_id = af.run(get_project_path()+'/')
res = af.wait_workflow_execution_finished(workflow_id)
sys.exit(res)
if __name__ == '__main__':
af.set_project_config_file(get_project_path() + '/project.yaml')
run_workflow()
def run_workflow(root_dir_path, project_yaml_path):
ai_flow.set_project_config_file(project_yaml_path)
res = ai_flow.run(root_dir_path,
dag_id='hello_world_example',
scheduler_type=ai_flow.SchedulerType.AIFLOW)
ai_flow.wait_workflow_execution_finished(res)
