本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# Pipelines 操作
您可以使用 Amazon Pipelin SageMaker es Python 软件开发工具包或 Amazon SageMaker Studio 中的 drag-and-drop可视化设计器来创作、查看、编辑、执行和监控您的机器学习工作流程。
以下屏幕截图显示了可用于创建和管理 Amazon Pipelines 的可视化设计 SageMaker 器。
![\[Studio 中流水线的可视 drag-and-drop界面屏幕截图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png)
部署管道后，您可以查看管道的有向无环图 (DAG)，并使用 Amazon SageMaker Studio 管理您的执行。 使用 SageMaker Studio，您可以获取有关当前和历史管道的信息、比较执行情况、查看执行的 DAG、获取元数据信息等。要了解如何从 Studio 查看管道，请参阅 [查看管道详情](pipelines-studio-list.md)。
**Topics**
+ [定义管道](define-pipeline.md)
+ [编辑管道](edit-pipeline-before-execution.md)
+ [运行管道](run-pipeline.md)
+ [停止管道](pipelines-studio-stop.md)
+ [查看管道详情](pipelines-studio-list.md)
+ [查看管道运行的详细信息](pipelines-studio-view-execution.md)
+ [下载管道定义文件](pipelines-studio-download.md)
+ [从管道访问实验数据](pipelines-studio-experiments.md)
+ [跟踪管道的发展历程](pipelines-lineage-tracking.md)
# 定义管道
要使用 Amazon Pipelines 编排工作流程，您必须以 JSON SageMaker 管道定义的形式生成有向无环图 (DAG)。DAG 规定了 ML 流程中涉及的不同步骤，如数据预处理、模型训练、模型评测和模型部署，以及这些步骤之间的依赖关系和数据流。下面的主题将向您展示如何生成管道定义。
您可以使用 Python SDK 或 Amaz SageMaker on SageMaker Studio 中的可视化 drag-and-drop管道设计器功能生成 JSON 管道定义。下图是您在本教程中创建的管道 DAG 的示意图：
![\[Studio 中流水线的可视 drag-and-drop界面屏幕截图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png)
您在以下章节中定义的管道解决了一个回归问题，即根据鲍鱼的物理测量值确定其年龄。有关包含本教程内容的可运行 Jupyter 笔记本，请参阅[使用 Amazon 模型构建管道编排作业](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.html)。 SageMaker
**注意**
您可以将模型位置作为训练步骤的属性进行引用，如 Github 中的 end-to-end示例[CustomerChurn 管道](https://github.com/aws-samples/customer-churn-sagemaker-pipelines-sample/blob/main/pipelines/customerchurn/pipeline.py)所示。
**Topics**
## 定义管道（Pipeline Designer）
以下演练将指导您完成使用流水线设计器创建准系统管道的 drag-and-drop步骤。如果您需要随时暂停或结束可视化设计器中的 Pipeline 编辑会话，请单击**导出**选项。这样就可以将管道的当前定义下载到本地环境中。之后，当您想恢复 Pipeline 编辑流程时，可以将相同的 JSON 定义文件导入可视化设计器。
### 创建 Processing 步骤
要创建数据处理作业步骤，请执行以下操作：
1. 按照 [启动亚马逊 SageMaker Studio](studio-updated-launch.md) 中的说明打开 Studio 管理控制台。
1. 在左侧导航窗格中，选择 **Pipelines**。
1. 选择**创建**。
1. 选择**空白**。
1. 在左侧边栏中选择**处理数据**，然后将其拖到画布上。
1. 在画布中，选择添加的**处理数据**步骤。
1. 要添加输入数据集，请在右侧边栏的**数据（输入）**下选择**添加**，然后选择一个数据集。
1. 要添加保存输出数据集的位置，请在右侧边栏的**数据（输出）**下选择**添加**，然后导航至目的地。
1. 填写右侧边栏中的其余字段。有关这些选项卡中字段的信息，请参阅 [sagemaker.workflow.steps。 ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)。
### 创建 Training 步骤
要设置模型训练步骤，请执行以下操作：
1. 在左侧边栏中选择**训练模型**，然后将其拖到画布上。
1. 在画布中选择添加的**训练模型**步骤。
1. 要添加输入数据集，请在右侧边栏的**数据（输入）**下选择**添加**，然后选择一个数据集。
1. 要选择保存模型构件的位置，请在**位置 (S3 URI)** 字段中输入 Amazon S3 URI，或选择 **Browse S3** 导航到目标位置。
1. 填写右侧边栏中的其余字段。有关这些选项卡中字段的信息，请参阅 [sagemaker.workflow.steps。 TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep)。
1. 单击并拖动光标，从上一节添加的**处理数据**步骤到**训练模型**步骤，创建连接两个步骤的边缘。
### 创建带有注册模型步骤的模型软件包
要创建带有模型注册步骤的模型软件包，请执行以下操作：
1. 在左侧边栏中选择**注册模型**，然后将其拖到画布上。
1. 在画布中，选择添加的**注册模型**步骤。
1. 要选择要注册的模型，请在**模型（输入）**下选择**添加**。
1. 选择**创建模型组**，将模型添加到新的模型组中。
1. 填写右侧边栏中的其余字段。有关这些选项卡中字段的信息，请参阅 [sagemaker.workflow.step\$1collections。 RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel)。
1. 单击并拖动光标，从上一节添加的**训练模型**步骤到**注册模型**步骤，创建连接两个步骤的边缘。
### 通过 Deploy 模型（端点）步骤将模型部署到端点
要使用模型部署步骤部署模型，请执行以下操作：
1. 在左侧边栏中选择**部署模型（端点）**，然后将其拖到画布上。
1. 在画布中，选择添加的**部署模型（端点）**步骤。
1. 要选择要部署的模型，请在**模型（输入）**下选择**添加**。
1. 选择**创建端点**单选按钮创建新端点。
1. 为端点输入**姓名**和**描述**。
1. 单击并拖动光标，从上一节添加的**注册模型**步骤到**部署模型（端点）**步骤，创建连接两个步骤的边缘。
1. 填写右侧边栏中的其余字段。
### 定义 Pipeline 参数
您可以配置一组 Pipeline 参数，其值可在每次执行时更新。要定义管道参数并设置默认值，请单击可视化设计器底部的齿轮图标。
### 保存 Pipeline
输入创建管道所需的全部信息后，点击可视化设计器底部的**保存**。这将在运行时验证管道是否存在任何潜在错误，并通知您。在处理自动验证检查标记的所有错误之前，**保存**操作不会成功。如果您想在以后继续编辑，可以在本地环境中将正在进行的管道保存为 JSON 定义。您可以点击可视化设计器底部的**导出**按钮，将管道导出为 JSON 定义文件。之后，要继续更新管道，请点击**导入**按钮上传 JSON 定义文件。
## 定义管道（SageMaker Python 开发工具包）
### 先决条件
要运行以下教程，请完成以下步骤：
+ 按照[创建笔记本实例](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-create-ws.html)中所述的步骤设置笔记本实例。这使您的角色有权读取和写入 Amazon S3，以及在 A SageMaker I 中创建训练、批量转换和处理任务。
+ 授予笔记本获取和传递自身角色的权限，如[修改角色权限策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy)中所示。添加以下 JSON 代码片段以将此策略附加到您的角色。将 `` 替换为用于创建笔记本实例的 ARN。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:GetRole",
"iam:PassRole"
],
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
+ 按照[修改角色信任策略中的步骤信任 SageMaker ](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-cli.html#roles-managingrole_edit-trust-policy-cli) AI 服务主体。将以下语句片段添加到角色的信任关系中：
```
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
```
#### 设置环境
使用以下代码块创建新的 SageMaker AI 会话。这将返回会话的角色 ARN。此角色 ARN 应是您设置为先决条件的执行角色 ARN。
```
import boto3
import sagemaker
import sagemaker.session
from sagemaker.workflow.pipeline_context import PipelineSession
region = boto3.Session().region_name
sagemaker_session = sagemaker.session.Session()
role = sagemaker.get_execution_role()
default_bucket = sagemaker_session.default_bucket()
pipeline_session = PipelineSession()
model_package_group_name = f"AbaloneModelPackageGroupName"
```
### 创建管道
**重要**
允许 Amazon SageMaker Studio 或 Amazon SageMaker Studio Classic 创建亚马逊 SageMaker资源的自定义 IAM 策略还必须授予向这些资源添加标签的权限。之所以需要为资源添加标签的权限，是因为 Studio 和 Studio Classic 会自动为创建的任何资源添加标签。如果 IAM 策略允许 Studio 和 Studio Classic 创建资源但不允许标记，则在尝试创建资源时可能会出现 AccessDenied “” 错误。有关更多信息，请参阅 [提供标记 A SageMaker I 资源的权限](security_iam_id-based-policy-examples.md#grant-tagging-permissions)。
[AWS 亚马逊 A SageMaker I 的托管策略](security-iam-awsmanpol.md)授予创建 SageMaker 资源的权限已经包括在创建这些资源时添加标签的权限。
从 SageMaker AI 笔记本实例运行以下步骤，创建包含以下步骤的管道：
+ 预处理
+ 训练
+ 评测
+ 条件评估
+ 模型注册
**注意**
您可以使用[ExecutionVariables](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables)和 [Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables) 函数来指定输出位置。 `ExecutionVariables`在运行时已解析。例如，`ExecutionVariables.PIPELINE_EXECUTION_ID` 解析为当前执行的 ID，可在不同运行中用作唯一标识符。
#### 步骤 1：下载数据集
此笔记本使用 UCI 机器学习鲍鱼数据集。该数据集包含以下特征：
+ `length` - 鲍鱼外壳最长测量值。
+ `diameter` - 垂直于长度方向的鲍鱼直径。
+ `height` - 带肉鲍鱼在壳内的高度。
+ `whole_weight` - 整只鲍鱼的重量。
+ `shucked_weight` - 从鲍鱼身上取出的肉的重量。
+ `viscera_weight` - 鲍鱼内脏出血后的重量。
+ `shell_weight` - 去肉和干燥后鲍鱼壳的重量。
+ `sex` - 鲍鱼的性别。“M”、“F”或“I”中的一个，其中“I”是幼鲍。
+ `rings` - 鲍鱼壳上的环数。
鲍鱼壳上的环数是其年龄的近似值，计算公式为 `age=rings + 1.5`。然而，获取这一数字是一项耗时的任务。您必须从锥体上切壳，将切面染色，然后通过显微镜计算环数。不过，其他物理测量数据比较容易获得。此笔记本使用该数据集，利用其他物理测量值来构建 rings 变量的预测模型。
**下载数据集**
1. 将数据集下载到您账户的默认 Amazon S3 存储桶中。
```
!mkdir -p data
local_path = "data/abalone-dataset.csv"
s3 = boto3.resource("s3")
s3.Bucket(f"sagemaker-servicecatalog-seedcode-{region}").download_file(
"dataset/abalone-dataset.csv",
local_path
)
base_uri = f"s3://{default_bucket}/abalone"
input_data_uri = sagemaker.s3.S3Uploader.upload(
local_path=local_path,
desired_s3_uri=base_uri,
)
print(input_data_uri)
```
1. 创建模型后，下载第二个数据集进行批量转换。
```
local_path = "data/abalone-dataset-batch.csv"
s3 = boto3.resource("s3")
s3.Bucket(f"sagemaker-servicecatalog-seedcode-{region}").download_file(
"dataset/abalone-dataset-batch",
local_path
)
base_uri = f"s3://{default_bucket}/abalone"
batch_data_uri = sagemaker.s3.S3Uploader.upload(
local_path=local_path,
desired_s3_uri=base_uri,
)
print(batch_data_uri)
```
#### 步骤 2：定义管道参数
此代码块为您的管道定义了以下参数：
+ `processing_instance_count` - 处理作业的实例数。
+ `input_data` - 输入数据在 Amazon S3 中的位置。
+ `batch_data` - 用于批量转换的输入数据在 Amazon S3 中的位置。
+ `model_approval_status` - 为 CI/CD 注册已训练模型的批准状态。有关更多信息，请参阅 [MLOps SageMaker 项目自动化](sagemaker-projects.md)。
```
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
model_approval_status = ParameterString(
name="ModelApprovalStatus",
default_value="PendingManualApproval"
)
input_data = ParameterString(
name="InputData",
default_value=input_data_uri,
)
batch_data = ParameterString(
name="BatchData",
default_value=batch_data_uri,
)
```
#### 步骤 3：确定特征工程的处理步骤
本节介绍如何创建一个处理步骤，从数据集中准备用于训练的数据。
**创建处理步骤**
1. 为处理脚本创建目录。
```
!mkdir -p abalone
```
1. 在 `/abalone` 目录中创建一个包含以下内容的名为 `preprocessing.py` 的文件。该预处理脚本将被传入处理步骤，以便在输入数据上运行。然后，训练步骤使用预处理的训练功能和标签来训练模型。评估步骤使用训练过的模型和预处理过的测试功能和标签对模型进行评估。该脚本使用 `scikit-learn` 执行以下操作：
+ 填入缺失的 `sex` 分类数据并对其进行编码，使其适合训练。
+ 缩放和标准化除 `rings` 和 `sex` 之外的所有数值字段。
+ 将数据拆分为训练、测试和验证数据集。
```
%%writefile abalone/preprocessing.py
import argparse
import os
import requests
import tempfile
import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
# Because this is a headerless CSV file, specify the column names here.
feature_columns_names = [
"sex",
"length",
"diameter",
"height",
"whole_weight",
"shucked_weight",
"viscera_weight",
"shell_weight",
]
label_column = "rings"
feature_columns_dtype = {
"sex": str,
"length": np.float64,
"diameter": np.float64,
"height": np.float64,
"whole_weight": np.float64,
"shucked_weight": np.float64,
"viscera_weight": np.float64,
"shell_weight": np.float64
}
label_column_dtype = {"rings": np.float64}
def merge_two_dicts(x, y):
z = x.copy()
z.update(y)
return z
if __name__ == "__main__":
base_dir = "/opt/ml/processing"
df = pd.read_csv(
f"{base_dir}/input/abalone-dataset.csv",
header=None,
names=feature_columns_names + [label_column],
dtype=merge_two_dicts(feature_columns_dtype, label_column_dtype)
)
numeric_features = list(feature_columns_names)
numeric_features.remove("sex")
numeric_transformer = Pipeline(
steps=[
("imputer", SimpleImputer(strategy="median")),
("scaler", StandardScaler())
]
)
categorical_features = ["sex"]
categorical_transformer = Pipeline(
steps=[
("imputer", SimpleImputer(strategy="constant", fill_value="missing")),
("onehot", OneHotEncoder(handle_unknown="ignore"))
]
)
preprocess = ColumnTransformer(
transformers=[
("num", numeric_transformer, numeric_features),
("cat", categorical_transformer, categorical_features)
]
)
y = df.pop("rings")
X_pre = preprocess.fit_transform(df)
y_pre = y.to_numpy().reshape(len(y), 1)
X = np.concatenate((y_pre, X_pre), axis=1)
np.random.shuffle(X)
train, validation, test = np.split(X, [int(.7*len(X)), int(.85*len(X))])
pd.DataFrame(train).to_csv(f"{base_dir}/train/train.csv", header=False, index=False)
pd.DataFrame(validation).to_csv(f"{base_dir}/validation/validation.csv", header=False, index=False)
pd.DataFrame(test).to_csv(f"{base_dir}/test/test.csv", header=False, index=False)
```
1. 创建要传递到处理步骤的 `SKLearnProcessor` 的实例。
```
from sagemaker.sklearn.processing import SKLearnProcessor
framework_version = "0.23-1"
sklearn_processor = SKLearnProcessor(
framework_version=framework_version,
instance_type="ml.m5.xlarge",
instance_count=processing_instance_count,
base_job_name="sklearn-abalone-process",
sagemaker_session=pipeline_session,
role=role,
)
```
1. 创建处理步骤。此步骤采用 `SKLearnProcessor`、输入和输出通道以及您创建的 `preprocessing.py` 脚本。这与 SageMaker AI Python SDK 中处理器实例的`run`方法非常相似。传入 `ProcessingStep` 的 `input_data` 参数是步骤本身的输入数据。处理器实例运行时会使用这些输入数据。
请注意在处理作业的输出配置中指定的 `"train`、`"validation` 和 `"test"` 命名通道。这样的步骤 `Properties` 可以在后续步骤中使用，并在运行时解析为运行时值。
```
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
processor_args = sklearn_processor.run(
inputs=[
ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
],
outputs=[
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
],
code="abalone/preprocessing.py",
)
step_process = ProcessingStep(
name="AbaloneProcess",
step_args=processor_args
)
```
#### 步骤 4：确定训练步骤
本节介绍如何使用 SageMaker AI [XGBoost算法](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html)根据处理步骤输出的训练数据训练模型。
**定义训练步骤**
1. 指定要保存训练模型的模型路径。
```
model_path = f"s3://{default_bucket}/AbaloneTrain"
```
1. 为 XGBoost 算法和输入数据集配置估计器。训练实例类型传递到估算器中。一个典型的训练脚本：
+ 从输入通道加载数据
+ 配置超参数训练
+ 训练模型
+ 将模型保存到 `model_dir`，以便日后托管
SageMaker AI 在训练作业结束`model.tar.gz`时以 a 的形式将模型上传到 Amazon S3。
```
from sagemaker.estimator import Estimator
image_uri = sagemaker.image_uris.retrieve(
framework="xgboost",
region=region,
version="1.0-1",
py_version="py3",
instance_type="ml.m5.xlarge"
)
xgb_train = Estimator(
image_uri=image_uri,
instance_type="ml.m5.xlarge",
instance_count=1,
output_path=model_path,
sagemaker_session=pipeline_session,
role=role,
)
xgb_train.set_hyperparameters(
objective="reg:linear",
num_round=50,
max_depth=5,
eta=0.2,
gamma=4,
min_child_weight=6,
subsample=0.7,
silent=0
)
```
1. 使用估计器实例和 `ProcessingStep` 的属性创建一个 `TrainingStep`。将 `"train"` 的 `S3Uri` 和 `"validation"` 输出通道传递给 `TrainingStep`。
```
from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TrainingStep
train_args = xgb_train.fit(
inputs={
"train": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train"
].S3Output.S3Uri,
content_type="text/csv"
),
"validation": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"validation"
].S3Output.S3Uri,
content_type="text/csv"
)
},
)
step_train = TrainingStep(
name="AbaloneTrain",
step_args = train_args
)
```
#### 步骤 5：确定模型评测的处理步骤
本节介绍如何创建处理步骤以评估模型的精度。该模型评测的结果用于条件步骤，以确定采取哪种运行路径。
**定义模型评测的处理步骤**
1. 在名为 `evaluation.py` 的 `/abalone` 目录中创建一个文件。此脚本在处理步骤中用于执行模型评测。它以经过训练的模型和测试数据集作为输入，然后生成包含分类评估指标的 JSON 文件。
```
%%writefile abalone/evaluation.py
import json
import pathlib
import pickle
import tarfile
import joblib
import numpy as np
import pandas as pd
import xgboost
from sklearn.metrics import mean_squared_error
if __name__ == "__main__":
model_path = f"/opt/ml/processing/model/model.tar.gz"
with tarfile.open(model_path) as tar:
tar.extractall(path=".")
model = pickle.load(open("xgboost-model", "rb"))
test_path = "/opt/ml/processing/test/test.csv"
df = pd.read_csv(test_path, header=None)
y_test = df.iloc[:, 0].to_numpy()
df.drop(df.columns[0], axis=1, inplace=True)
X_test = xgboost.DMatrix(df.values)
predictions = model.predict(X_test)
mse = mean_squared_error(y_test, predictions)
std = np.std(y_test - predictions)
report_dict = {
"regression_metrics": {
"mse": {
"value": mse,
"standard_deviation": std
},
},
}
output_dir = "/opt/ml/processing/evaluation"
pathlib.Path(output_dir).mkdir(parents=True, exist_ok=True)
evaluation_path = f"{output_dir}/evaluation.json"
with open(evaluation_path, "w") as f:
f.write(json.dumps(report_dict))
```
1. 创建 `ScriptProcessor` 的实例，用于创建 `ProcessingStep`。
```
from sagemaker.processing import ScriptProcessor
script_eval = ScriptProcessor(
image_uri=image_uri,
command=["python3"],
instance_type="ml.m5.xlarge",
instance_count=1,
base_job_name="script-abalone-eval",
sagemaker_session=pipeline_session,
role=role,
)
```
1. 创建一个使用处理实例、输入和输出通道以及 `evaluation.py` 脚本的处理器的 `ProcessingStep`。传入：
+ `step_train` 训练步骤中的 `S3ModelArtifacts` 属性
+ `step_process` 处理步骤的 `"test"` 输出通道的 `S3Uri`
这与 SageMaker AI Python SDK 中处理器实例的`run`方法非常相似。
```
from sagemaker.workflow.properties import PropertyFile
evaluation_report = PropertyFile(
name="EvaluationReport",
output_name="evaluation",
path="evaluation.json"
)
eval_args = script_eval.run(
inputs=[
ProcessingInput(
source=step_train.properties.ModelArtifacts.S3ModelArtifacts,
destination="/opt/ml/processing/model"
),
ProcessingInput(
source=step_process.properties.ProcessingOutputConfig.Outputs[
"test"
].S3Output.S3Uri,
destination="/opt/ml/processing/test"
)
],
outputs=[
ProcessingOutput(output_name="evaluation", source="/opt/ml/processing/evaluation"),
],
code="abalone/evaluation.py",
)
step_eval = ProcessingStep(
name="AbaloneEval",
step_args=eval_args,
property_files=[evaluation_report],
)
```
#### 步骤 6： CreateModelStep 为批量转换定义一个
**重要**
我们建议使用从 P [模型步骤](build-and-manage-steps-types.md#step-type-model) ython 软件开发工具包的 2.90.0 版本开始创建模型。 SageMaker `CreateModelStep`将继续在以前版本的 SageMaker Python SDK 中运行，但不再受支持。
本节介绍如何根据训练步骤的输出创建 SageMaker AI 模型。此模型用于对新数据集进行批量转换。该步骤会传入条件步骤，只有当条件步骤的结果为 `true` 时才会运行。
**CreateModelStep 为批量转换定义一个**
1. 创建 A SageMaker I 模型。从 `step_train` 训练步骤传入 `S3ModelArtifacts` 属性。
```
from sagemaker.model import Model
model = Model(
image_uri=image_uri,
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
sagemaker_session=pipeline_session,
role=role,
)
```
1. 为 SageMaker AI 模型定义模型输入。
```
from sagemaker.inputs import CreateModelInput
inputs = CreateModelInput(
instance_type="ml.m5.large",
accelerator_type="ml.eia1.medium",
)
```
1. `CreateModelStep`使用您定义的`CreateModelInput`和 SageMaker AI 模型实例创建您的。
```
from sagemaker.workflow.steps import CreateModelStep
step_create_model = CreateModelStep(
name="AbaloneCreateModel",
model=model,
inputs=inputs,
)
```
#### 步骤 7：定义一个 TransformStep 以执行批量转换
本节介绍如何在模型训练完毕后创建 `TransformStep` 以对数据集执行批量转换。该步骤会传入条件步骤，只有当条件步骤的结果为 `true` 时才会运行。
**要定义 TransformStep 要执行批量转换**
1. 使用适当的计算实例类型、实例数量和所需的输出 Amazon S3 存储桶 URI 创建转换器实例。从 `step_create_model` `CreateModel` 步骤传入 `ModelName` 属性。
```
from sagemaker.transformer import Transformer
transformer = Transformer(
model_name=step_create_model.properties.ModelName,
instance_type="ml.m5.xlarge",
instance_count=1,
output_path=f"s3://{default_bucket}/AbaloneTransform"
)
```
1. 使用您定义的转换器实例和 `batch_data` 管道参数创建 `TransformStep`。
```
from sagemaker.inputs import TransformInput
from sagemaker.workflow.steps import TransformStep
step_transform = TransformStep(
name="AbaloneTransform",
transformer=transformer,
inputs=TransformInput(data=batch_data)
)
```
#### 步骤 8：定义创建模型包的 RegisterModel 步骤
**重要**
我们建议使用从 P [模型步骤](build-and-manage-steps-types.md#step-type-model) ython SDK 版本 2.90.0 起注册模型。 SageMaker `RegisterModel`将继续在以前版本的 SageMaker Python SDK 中运行，但不再受支持。
本节将介绍如何创建 `RegisterModel` 实例。在管道中运行 `RegisterModel` 的结果是一个模型软件包。模型包是一种可重复使用的模型构件抽象，它封装了推理所需的所有要素。它由一个定义要使用的推理映像的推理规范和一个可选的模型权重位置组成。模型包组是模型包的集合。您可以为管道使用 `ModelPackageGroup`，为每次管道运行向组中添加新版本和模型软件包。有关模型注册表的更多信息，请参阅[利用模型注册中心进行模型注册部署](model-registry.md)。
该步骤会传入条件步骤，只有当条件步骤的结果为 `true` 时才会运行。
**定义创建模型包的 RegisterModel 步骤**
+ 使用您用于训练步骤的估算器实例构造一个 `RegisterModel` 步骤。从 `step_train` 训练步骤传入 `S3ModelArtifacts` 属性并指定 `ModelPackageGroup`。Pipelines 会为您创建此 `ModelPackageGroup`。
```
from sagemaker.model_metrics import MetricsSource, ModelMetrics
from sagemaker.workflow.step_collections import RegisterModel
model_metrics = ModelMetrics(
model_statistics=MetricsSource(
s3_uri="{}/evaluation.json".format(
step_eval.arguments["ProcessingOutputConfig"]["Outputs"][0]["S3Output"]["S3Uri"]
),
content_type="application/json"
)
)
step_register = RegisterModel(
name="AbaloneRegisterModel",
estimator=xgb_train,
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
content_types=["text/csv"],
response_types=["text/csv"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name=model_package_group_name,
approval_status=model_approval_status,
model_metrics=model_metrics
)
```
#### 步骤 9：定义条件步骤以验证模型的准确性
`ConditionStep` 允许 Pipelines 根据步骤属性的条件在管道 DAG 中支持有条件运行。在这种情况下，只有当模型的精度超过要求值时，才需要注册模型软件包。模型的准确性由模型评测步骤决定。如果精度超过所需值，管道还会创建 A SageMaker I 模型并对数据集运行批量转换。本节介绍如何定义条件步骤。
**定义条件步骤以验证模型精度**
1. 使用模型评测处理步骤 `step_eval` 的输出中找到的精度值定义 `ConditionLessThanOrEqualTo` 条件。使用您在处理步骤中编制索引的属性文件以及相应的 JSONPath 均方误差值来获取此输出。`"mse"`
```
from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.functions import JsonGet
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=evaluation_report,
json_path="regression_metrics.mse.value"
),
right=6.0
)
```
1. 构造一个 `ConditionStep`。传入 `ConditionEquals` 条件，如果条件通过，则将模型包注册和批量转换步骤设置为后续步骤。
```
step_cond = ConditionStep(
name="AbaloneMSECond",
conditions=[cond_lte],
if_steps=[step_register, step_create_model, step_transform],
else_steps=[],
)
```
#### 步骤 10：创建管道
现在，您已经创建了所有步骤，请将它们组合成一个管道。
**创建管道**
1. 为您的管道定义以下内容：`name`、`parameters` 和 `steps`。名称在 `(account, region)` 对中必须唯一。
**注意**
一个步骤只能在管道的步骤列表或条件步骤的 if/else 步骤列表中出现一次。不能同时出现在两者中。
```
from sagemaker.workflow.pipeline import Pipeline
pipeline_name = f"AbalonePipeline"
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count,
model_approval_status,
input_data,
batch_data,
],
steps=[step_process, step_train, step_eval, step_cond],
)
```
1. （可选）检查 JSON 管道定义以确保其格式正确。
```
import json
json.loads(pipeline.definition())
```
此管道定义已准备好提交给 SageMaker AI。在下一个教程中，您将此管道提交给 SageMaker AI 并开始运行。
## 定义管道 (JSON)
您也可以使用 [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_pipeline) 或 [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-pipeline.html) 创建管道。创建管道需要管道定义，该定义是一个定义管道每个步骤的 JSON 对象。 SageMaker SDK 提供了一种构造管道定义的简单方法，您可以将其与 APIs 前面提到的任何定义一起使用来创建管道本身。在不使用 SDK 的情况下，用户必须编写原始 JSON 定义来创建管道，而无需进行 SageMaker Python SDK 提供的任何错误检查。要查看管道 JSON 定义的架构，请参阅 [ SageMaker AI 管道定义 JSON 架构](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/)。以下代码示例显示了 SageMaker AI 管道定义 JSON 对象的示例：
```
{'Version': '2020-12-01',
'Metadata': {},
'Parameters': [{'Name': 'ProcessingInstanceType',
'Type': 'String',
'DefaultValue': 'ml.m5.xlarge'},
{'Name': 'ProcessingInstanceCount', 'Type': 'Integer', 'DefaultValue': 1},
{'Name': 'TrainingInstanceType',
'Type': 'String',
'DefaultValue': 'ml.m5.xlarge'},
{'Name': 'ModelApprovalStatus',
'Type': 'String',
'DefaultValue': 'PendingManualApproval'},
{'Name': 'ProcessedData',
'Type': 'String',
'DefaultValue': 'S3_URL',
{'Name': 'InputDataUrl',
'Type': 'String',
'DefaultValue': 'S3_URL',
'PipelineExperimentConfig': {'ExperimentName': {'Get': 'Execution.PipelineName'},
'TrialName': {'Get': 'Execution.PipelineExecutionId'}},
'Steps': [{'Name': 'ReadTrainDataFromFS',
'Type': 'Processing',
'Arguments': {'ProcessingResources': {'ClusterConfig': {'InstanceType': 'ml.m5.4xlarge',
'InstanceCount': 2,
'VolumeSizeInGB': 30}},
'AppSpecification': {'ImageUri': 'IMAGE_URI',
'ContainerArguments': [....]},
'RoleArn': 'ROLE',
'ProcessingInputs': [...],
'ProcessingOutputConfig': {'Outputs': [.....]},
'StoppingCondition': {'MaxRuntimeInSeconds': 86400}},
'CacheConfig': {'Enabled': True, 'ExpireAfter': '30d'}},
...
...
...
}
```
**下一步：**[运行管道](run-pipeline.md)
# 编辑管道
要在运行管道之前对其进行更改，请执行以下操作：
1. 按照[启动 Amazon SageMaker Studio 中的说明打开 SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html)。
1. 在 Studio 的左导航窗格中，选择 **Pipelines**。
1. 选择管道名称以查看有关管道的详细信息。
1. 选择**执行**选项卡。
1. 选择管道执行的名称。
1. 选择**编辑**打开管道设计器。
1. 根据需要更新步骤之间的边缘或步骤配置，然后点击**保存**。
编辑后保存管道会自动生成新的版本号。
1. 选择**运行**。
# 运行管道
将管道步骤定义为有向无环图 (DAG) 后，就可以运行管道，执行 DAG 中定义的步骤。以下演练向您展示了如何使用亚马逊 SageMaker Studio 中的 drag-and-drop可视化编辑器或亚马逊 SageMaker Python SDK 运行亚马逊 A SageMaker I 管道。
## 运行管道（Pipeline Designer）
要开始执行新的管道，请执行以下操作：
------
#### [ Studio ]
1. 按照[启动 Amazon SageMaker Studio 中的说明打开 SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html)。
1. 在左侧的导航窗格中，选择**管道**。
1. （可选）要按名称筛选管道列表，请在搜索字段中输入管道的全名或部分名称。
1. 选择管道名称以打开管道详细信息视图。
1. 选择右上角的**可视化编辑器**。
1. 要从最新版本启动执行，请选择**执行**。
1. 要从特定版本启动执行，请执行以下步骤：
+ 选择底部工具栏中的版本图标以打开版本面板。
+ 选择要执行的管道版本。
+ 将鼠标悬停在版本项上方以显示三点菜单，然后选择**执行**。
+ （可选）要查看管道的上一个版本，请从版本面板中的三点菜单中选择**预览**。您也可以在通知栏中选择**编辑**来编辑版本。
**注意**
如果管道失败，状态横幅将显示 **Failed** 状态。对失败步骤进行问题排查后，在状态横幅上选择**重试**以从该步骤继续运行管道。
------
#### [ Studio Classic ]
1. 登录亚马逊 SageMaker Studio 经典版。有关更多信息，请参阅[启动 Amazon SageMaker Studio 经典版](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html)。
1. 在 Studio Classic 侧边栏中，选择**主页**图标 (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/studio/icons/house.png))。
1. 从菜单中选择**管道**。
1. 要按名称缩小管道列表的范围，请在搜索字段中输入管道的全名或部分名称。
1. 选择管道名称。
1. 从执行列表的**执行**或**图表**选项卡中，选择**创建执行**。
1. 输入或更新以下所需信息：
+ **Name** - 对于您在 AWS 区域中的账户必须唯一。
+ **ProcessingInstanceCount**— 用于处理的实例数。
+ **ModelApprovalStatus**— 为了您的方便。
+ **InputDataUrl**— 输入数据的亚马逊 S3 URI。
1. 选择**启动**。
管道运行后，您可以在状态横幅上选择**查看详情**查看执行详情。
要停止运行，请在状态横幅上选择**停止**。要从停止处恢复执行，请在状态横幅上选择**恢复**。
**注意**
如果管道失败，状态横幅将显示 **Failed** 状态。对失败步骤进行问题排查后，在状态横幅上选择**重试**以从该步骤继续运行管道。
------
## 运行管道 (SageMaker Python 开发工具包)
使用 SageMaker AI Python SDK 创建管道定义后，您可以将其提交给 SageMaker AI 以开始执行。以下教程展示了如何提交管道、开始执行、检查执行结果以及删除管道。
**Topics**
+ [先决条件](#run-pipeline-prereq)
+ [步骤 1：启动管道](#run-pipeline-submit)
+ [步骤 2：检查管道执行](#run-pipeline-examine)
+ [步骤 3：覆盖管道执行的默认参数](#run-pipeline-parametrized)
+ [步骤 4：停止并删除管道执行](#run-pipeline-delete)
### 先决条件
本教程要求以下项目：
+ SageMaker 笔记本实例。
+ Pipelines 管道定义。本教程假设您使用的是完成[定义管道](define-pipeline.md)教程后创建的管道定义。
### 步骤 1：启动管道
首先，您需要启动管道。
**启动管道**
1. 检查 JSON 管道定义以确保其格式正确。
```
import json
json.loads(pipeline.definition())
```
1. 将管道定义提交给 Pipelines 服务，以便创建一个管道（如果它不存在）或更新现有的管道。传入的角色用于 Pipelines 创建步骤中定义的所有作业。
```
pipeline.upsert(role_arn=role)
```
1. 启动管道执行。
```
execution = pipeline.start()
```
### 步骤 2：检查管道执行
接下来，您需要检查管道执行。
**检查管道执行**
1. 描述管道执行状态，确保其已成功创建并启动。
```
execution.describe()
```
1. 等待执行完成。
```
execution.wait()
```
1. 列出执行步骤及其状态。
```
execution.list_steps()
```
您的输出应与以下内容类似：
```
[{'StepName': 'AbaloneTransform',
'StartTime': datetime.datetime(2020, 11, 21, 2, 41, 27, 870000, tzinfo=tzlocal()),
'EndTime': datetime.datetime(2020, 11, 21, 2, 45, 50, 492000, tzinfo=tzlocal()),
'StepStatus': 'Succeeded',
'CacheHitResult': {'SourcePipelineExecutionArn': ''},
'Metadata': {'TransformJob': {'Arn': 'arn:aws:sagemaker:us-east-2:111122223333:transform-job/pipelines-cfvy1tjuxdq8-abalonetransform-ptyjoef3jy'}}},
{'StepName': 'AbaloneRegisterModel',
'StartTime': datetime.datetime(2020, 11, 21, 2, 41, 26, 929000, tzinfo=tzlocal()),
'EndTime': datetime.datetime(2020, 11, 21, 2, 41, 28, 15000, tzinfo=tzlocal()),
'StepStatus': 'Succeeded',
'CacheHitResult': {'SourcePipelineExecutionArn': ''},
'Metadata': {'RegisterModel': {'Arn': 'arn:aws:sagemaker:us-east-2:111122223333:model-package/abalonemodelpackagegroupname/1'}}},
{'StepName': 'AbaloneCreateModel',
'StartTime': datetime.datetime(2020, 11, 21, 2, 41, 26, 895000, tzinfo=tzlocal()),
'EndTime': datetime.datetime(2020, 11, 21, 2, 41, 27, 708000, tzinfo=tzlocal()),
'StepStatus': 'Succeeded',
'CacheHitResult': {'SourcePipelineExecutionArn': ''},
'Metadata': {'Model': {'Arn': 'arn:aws:sagemaker:us-east-2:111122223333:model/pipelines-cfvy1tjuxdq8-abalonecreatemodel-jl94rai0ra'}}},
{'StepName': 'AbaloneMSECond',
'StartTime': datetime.datetime(2020, 11, 21, 2, 41, 25, 558000, tzinfo=tzlocal()),
'EndTime': datetime.datetime(2020, 11, 21, 2, 41, 26, 329000, tzinfo=tzlocal()),
'StepStatus': 'Succeeded',
'CacheHitResult': {'SourcePipelineExecutionArn': ''},
'Metadata': {'Condition': {'Outcome': 'True'}}},
{'StepName': 'AbaloneEval',
'StartTime': datetime.datetime(2020, 11, 21, 2, 37, 34, 767000, tzinfo=tzlocal()),
'EndTime': datetime.datetime(2020, 11, 21, 2, 41, 18, 80000, tzinfo=tzlocal()),
'StepStatus': 'Succeeded',
'CacheHitResult': {'SourcePipelineExecutionArn': ''},
'Metadata': {'ProcessingJob': {'Arn': 'arn:aws:sagemaker:us-east-2:111122223333:processing-job/pipelines-cfvy1tjuxdq8-abaloneeval-zfraozhmny'}}},
{'StepName': 'AbaloneTrain',
'StartTime': datetime.datetime(2020, 11, 21, 2, 34, 55, 867000, tzinfo=tzlocal()),
'EndTime': datetime.datetime(2020, 11, 21, 2, 37, 34, 34000, tzinfo=tzlocal()),
'StepStatus': 'Succeeded',
'CacheHitResult': {'SourcePipelineExecutionArn': ''},
'Metadata': {'TrainingJob': {'Arn': 'arn:aws:sagemaker:us-east-2:111122223333:training-job/pipelines-cfvy1tjuxdq8-abalonetrain-tavd6f3wdf'}}},
{'StepName': 'AbaloneProcess',
'StartTime': datetime.datetime(2020, 11, 21, 2, 30, 27, 160000, tzinfo=tzlocal()),
'EndTime': datetime.datetime(2020, 11, 21, 2, 34, 48, 390000, tzinfo=tzlocal()),
'StepStatus': 'Succeeded',
'CacheHitResult': {'SourcePipelineExecutionArn': ''},
'Metadata': {'ProcessingJob': {'Arn': 'arn:aws:sagemaker:us-east-2:111122223333:processing-job/pipelines-cfvy1tjuxdq8-abaloneprocess-mgqyfdujcj'}}}]
```
1. 管道执行完成后，从 Amazon S3 下载生成的 `evaluation.json` 文件以检查报告。
```
evaluation_json = sagemaker.s3.S3Downloader.read_file("{}/evaluation.json".format(
step_eval.arguments["ProcessingOutputConfig"]["Outputs"][0]["S3Output"]["S3Uri"]
))
json.loads(evaluation_json)
```
### 步骤 3：覆盖管道执行的默认参数
您可以通过指定不同的管道参数来覆盖默认值，从而运行管道的其他执行。
**覆盖默认参数**
1. 创建管道执行。这将启动另一个管道执行，并将模型批准状态覆盖设置为“已批准”。这意味着该`RegisterModel`步骤生成的模型包版本已自动准备好通过 CI/CD 管道（例如 Pro SageMaker jects）进行部署。有关更多信息，请参阅 [MLOps SageMaker 项目自动化](sagemaker-projects.md)。
```
execution = pipeline.start(
parameters=dict(
ModelApprovalStatus="Approved",
)
)
```
1. 等待执行完成。
```
execution.wait()
```
1. 列出执行步骤及其状态。
```
execution.list_steps()
```
1. 管道执行完成后，从 Amazon S3 下载生成的 `evaluation.json` 文件以检查报告。
```
evaluation_json = sagemaker.s3.S3Downloader.read_file("{}/evaluation.json".format(
step_eval.arguments["ProcessingOutputConfig"]["Outputs"][0]["S3Output"]["S3Uri"]
))
json.loads(evaluation_json)
```
### 步骤 4：停止并删除管道执行
完成管道后，您可以停止任何正在进行的执行并删除管道。
**停止并删除管道执行**
1. 停止管道执行。
```
execution.stop()
```
1. 删除管道。
```
pipeline.delete()
```
# 停止管道
您可以在 Amazon SageMaker Studio 控制台中停止管道运行。
要停止在 Amazon SageMaker Studio 控制台中执行管道，请根据您使用的是 Studio 还是 Studio Classic 完成以下步骤。
------
#### [ Studio ]
1. 在左侧导航窗格中，选择 **Pipelines**。
1. （可选）要按名称筛选管道列表，请在搜索字段中输入管道的全名或部分名称。
1. 选择管道名称。
1. 选择**执行**选项卡。
1. 选择要停止的执行。
1. 选择**停止**。要从停止的位置恢复执行，请选择**恢复**
------
#### [ Studio Classic ]
1. 登录亚马逊 SageMaker Studio 经典版。有关更多信息，请参阅[启动 Amazon SageMaker Studio 经典版](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html)。
1. 在 Studio Classic 侧边栏中，选择**主页**图标 (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/studio/icons/house.png))。
1. 从菜单中选择**管道**。
1. 要按名称缩小管道列表的范围，请在搜索字段中输入管道的全名或部分名称。
1. 要停止管道运行，请在管道的状态横幅上选择**查看详情**，然后选择**停止**。要从停止的位置恢复执行，请选择**恢复**。
------
# 查看管道详情
您可以查看 SageMaker AI 管道的详细信息以了解其参数、其步骤的依赖关系，或者监控其进度和状态。这可以帮助您排除故障或优化工作流程。您可以使用 Amazon SageMaker Studio 控制台访问给定管道的详细信息，并浏览其执行历史记录、定义、参数和元数据。
或者，如果您的管道与 A SageMaker I 项目关联，则可以从该项目的详细信息页面访问管道详细信息。有关更多信息，请参阅 [查看项目资源](sagemaker-projects-resources.md)。
要查看 SageMaker AI 管道的详细信息，请根据您使用的是 Studio 还是 Studio Classic 完成以下步骤。
**注意**
当管道需要在要上传到 Amazon S3 并用于将模型部署到 Amazon S3 并用于将模型部署到 A SageMaker I 终端节点的压缩模型文件 (model.tar.gz) 中包含自定义脚本时，就会发生模型重新打包。当 SageMaker AI pipeline 训练模型并将其注册到模型注册表时，*如果*训练作业的训练模型输出需要包含自定义推理脚本，则会引入重新打包步骤。重新打包步骤解压缩该模型，添加一个新脚本，然后重新压缩该模型。运行管道会将重新打包步骤添加为训练作业。
------
#### [ Studio ]
1. 按照[启动 Amazon SageMaker Studio 中的说明打开 SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html) 控制台。
1. 在左侧导航窗格中，选择 **Pipelines**。
1. （可选）要按名称筛选管道列表，请在搜索字段中输入管道的全名或部分名称。
1. 选择管道名称以查看有关管道的详细信息。
1. 选择以下选项卡之一查看管道详细信息：
+ **执行** - 有关执行的详细信息。
+ **图表**：管道图，包括所有步骤。
+ **参数**：与管道相关的运行参数和指标。
+ **信息**：与管道相关的元数据，如标签、管道 Amazon 资源名称 (ARN) 和角色 ARN。您还可以在此页面编辑管道描述。
------
#### [ Studio Classic ]
1. 登录亚马逊 SageMaker Studio 经典版。有关更多信息，请参阅[启动 Amazon SageMaker Studio 经典版](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html)。
1. 在 Studio Classic 侧边栏中，选择**主页**图标 (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/studio/icons/house.png))。
1. 从菜单中选择**管道**。
1. 要按名称缩小管道列表的范围，请在搜索字段中输入管道的全名或部分名称。
1. 选择管道名称以查看有关管道的详细信息。管道详细信息选项卡将打开，并显示管道执行列表。您可以启动执行，也可以选择其他一个选项卡来了解管道的更多信息。使用 **Property Inspector** 图标 (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/studio/icons/gears.png)) 选择要显示的列。
1. 在管道详细信息页面上，选择以下选项卡之一以查看有关管道的详细信息：
+ **执行** - 有关执行的详细信息。您可以通过此选项卡或**图表**选项卡创建执行。
+ **图表** - 管道的 DAG。
+ **参数** - 包括模型批准状态。
+ **设置** - 与管道关联的元数据。您可以从此选项卡下载管道定义文件并编辑管道名称和描述。
------
# 查看管道运行的详细信息
您可以查看特定 SageMaker AI 管道运行的详细信息。这可以帮助您：
+ 找出并解决运行过程中可能出现的问题，如步骤失败或意外错误。
+ 比较不同管道执行的结果，了解输入数据或参数的变化对整个工作流程的影响。
+ 找出瓶颈和优化机会。
要查看管道运行的详细信息，请根据您使用的是 Studio 还是 Studio Classic 完成以下步骤。
------
#### [ Studio ]
1. 按照[启动 Amazon SageMaker Studio 中的说明打开 SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html) 控制台。
1. 在左侧导航窗格中，选择 **Pipelines**。
1. （可选）要按名称筛选管道列表，请在搜索字段中输入管道的全名或部分名称。
1. 选择管道名称以查看有关管道的详细信息。
1. 选择**执行**选项卡。
1. 选择要查看的管道执行名称。会出现该执行的管道图。
1. 选择图表中的任何管道步骤，即可在右侧边栏看到步骤设置。
1. 选择以下选项卡之一，查看更多管道详情：
+ **定义**：管道图，包括所有步骤。
+ **参数** - 包括模型批准状态。
+ **详情**：与管道相关的元数据，如标签、管道 Amazon 资源名称（ARN）和角色 ARN。您还可以在此页面编辑管道描述。
------
#### [ Studio Classic ]
1. 登录亚马逊 SageMaker Studio 经典版。有关更多信息，请参阅[启动 Amazon SageMaker Studio 经典版](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html)。
1. 在 Studio Classic 侧边栏中，选择**主页**图标 (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/studio/icons/house.png))。
1. 从菜单中选择**管道**。
1. 要按名称缩小管道列表的范围，请在搜索字段中输入管道的全名或部分名称。
1. 选择管道名称。管道的**执行**页面打开。
1. 在**执行**页面中，选择一个执行名称，查看有关执行的详细信息。执行详细信息选项卡将打开，并显示管道中步骤的图表。
1. 要按名称搜索步骤，请在搜索字段中输入与步骤名称匹配的字符。使用图表右下方的大小调整图标可以放大和缩小图表、将图表调整到适合屏幕，以及将图表扩展到全屏。要聚焦于图表的特定部分，可以选择图表的空白区域，然后拖动图表使其居中。
![\[\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/yosemite/execution-graph-w-input.png)
1. 在图表中选择一个管道步骤，查看该步骤的详细信息。在上面的屏幕截图中，选择了一个训练步骤并显示了以下选项卡：
+ **输入** - 训练输入。如果输入源来自 Amazon Simple Storage Service (Amazon S3)，请选择该链接以在 Amazon S3 控制台中查看该文件。
+ **输出** - 训练输出，例如指标、图表、文件和评估结果。这些图表是使用[追踪](https://sagemaker-experiments.readthedocs.io/en/latest/tracker.html#smexperiments.tracker.Tracker.log_precision_recall)器生成的 APIs。
+ **日志**-步骤生成的 Amazon CloudWatch 日志。
+ **信息** - 与该步骤关联的参数和元数据。
![\[\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/yosemite/execution-graph-info.png)
------
# 下载管道定义文件
您可以直接从 Amazon SageMaker Studio 用户界面下载 SageMaker 人工智能管道的定义文件。您可以将此管道定义文件用于以下用途：
+ 备份和恢复：使用下载的文件创建管道配置备份，以便在基础设施发生故障或意外更改时进行恢复。
+ 版本控制：将管道定义文件存储在源代码控制系统中，以跟踪管道的更改，并在需要时恢复到以前的版本。
+ 编程交互：使用管道定义文件作为 SageMaker SDK 的输入或 AWS CLI。
+ 与自动化流程集成：将管道定义集成到您的 CI/CD 工作流程或其他自动化流程中。
要下载管道的定义文件，请根据您使用的是 Studio 还是 Studio Classic 完成以下步骤。
------
#### [ Studio ]
1. 按照[启动 Amazon SageMaker Studio 中的说明打开 SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html) 控制台。
1. 在左侧导航窗格中，选择 **Pipelines**。
1. （可选）要按名称筛选管道列表，请在搜索字段中输入管道的全名或部分名称。
1. 选择管道名称。打开**执行**页面并显示管道执行列表。
1. 停留在**执行**页面，或选择管道执行表左侧的**图表**、**信息**或**参数**页面。您可以从这些网页中下载管道定义。
1. 在页面右上方，选择垂直省略号，然后选择**下载管道定义 (JSON)**。
------
#### [ Studio Classic ]
1. 登录亚马逊 SageMaker Studio 经典版。有关更多信息，请参阅[启动 Amazon SageMaker Studio 经典版](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html)。
1. 在 Studio Classic 侧边栏中，选择**主页**图标 (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/studio/icons/house.png))。
1. 从菜单中选择**管道**。
1. 要按名称缩小管道列表的范围，请在搜索字段中输入管道的全名或部分名称。
1. 选择管道名称。
1. 选择**设置**选项卡。
1. 选择**下载管道定义文件**。
------
# 从管道访问实验数据
**注意**
SageMaker 实验功能仅在 Studio Classic 中提供。
当你创建管道并指定 [pipeline\$1experiment\$1config](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.pipeline_experiment_config) 时，Pipelines 会默认创建以下 SageMaker 实验实体（如果它们不存在）：
+ 管道的实验
+ 每次执行管道时的运行组
+ 在管道步骤中创建的每个 SageMaker AI 作业的运行次数
有关实验如何与管道集成的信息，请参阅 [亚马逊 SageMaker 实验集成](pipelines-experiments.md)。有关 SageMaker 实验的更多信息，请参阅[Studio 经典版中的亚马逊 SageMaker 实验](experiments.md)。
您可以从管道执行列表或实验列表中查看与管道相关的运行列表。
**从管道执行列表中查看运行列表**
1. 要查看管道执行列表，请按照 [查看管道详情](pipelines-studio-list.md) 的 *Studio Classic* 选项卡中的前五个步骤操作。
1. 在屏幕右上方，选择**筛选器**图标 (![\[Funnel or filter icon representing data filtering or narrowing down options.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/jumpstart/jumpstart-filter-icon.png))。
1. 选择**实验**。如果创建管道时未停用实验集成，则实验名称将显示在执行列表中。
**注意**
Amaz [on Python SageMaker ](https://sagemaker.readthedocs.io/en/stable) SDK 的 v2.41.0 中引入了实验集成。使用早期版本 SDK 创建的管道默认情况下不与实验集成。
1. 选择您选择的实验，查看与该实验相关的运行组和运行。
**从实验列表中查看运行列表**
1. 在 Studio Classic 的左侧边栏，选择**主页**图标 (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/studio/icons/house.png))。
1. 从菜单中选择**实验**。
1. 使用搜索栏或**筛选器**图标 (![\[Funnel or filter icon representing data filtering or narrowing down options.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/jumpstart/jumpstart-filter-icon.png)) 将列表筛选为管道创建的实验。
1. 打开实验名称并查看管道创建的运行列表。
# 跟踪管道的发展历程
在本教程中，您将使用 Amazon SageMaker Studio 来跟踪亚马逊 A SageMaker I 机器学习管道的血统。
该管道由 Amazon [ SageMaker 示例 GitHub ](https://github.com/awslabs/amazon-sagemaker-examples)存储库中的 “使用[亚马逊 SageMaker 模型构建管道编排任务](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.html)” 笔记本创建。有关如何创建管道的详细信息，请参阅[定义管道](define-pipeline.md)。
Studio 中的世系跟踪以有向无环图 (DAG) 为中心。DAG 表示管道中的步骤。在 DAG 中，您可以跟踪从任何步骤到任何其他步骤的世系。下图显示了管道中的步骤。这些步骤在 Studio 中显示为 DAG。
![\[\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/yosemite/pipeline-tutorial-steps.png)
要在 Amazon SageMaker Studio 控制台中跟踪管道的血统，请根据您使用的是 Studio 还是 Studio Classic 完成以下步骤。
------
#### [ Studio ]
**跟踪管道的世系**
1. 按照[启动 Amazon SageMaker Studio 中的说明打开 SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html) 控制台。
1. 在左侧导航窗格中，选择 **Pipelines**。
1. （可选）要按名称筛选管道列表，请在搜索字段中输入管道的全名或部分名称。
1. 在**名称**列中，选择管道名称以查看管道的详细信息。
1. 选择**执行**选项卡。
1. 在**执行**表的**名称**列中，选择要查看的管道执行名称。
1. 在**执行**页面右上方，选择垂直省略号，然后选择**下载管道定义 (JSON)**。您可以查看该文件以了解管道图表的定义方式。
1. 选择**编辑**打开管道设计器。
1. 使用画布右上角的大小调整和缩放控件可以放大或缩小图表，将图表调整到适合屏幕，或将图表扩展到全屏。
1. 要查看训练、验证和测试数据集，请完成以下步骤：
1. 选择管道图中的处理步骤。
1. 在右侧边栏选择**概览**选项卡。
1. 在**文件**部分，找到训练、验证和测试数据集的 Amazon S3 路径。
1. 要查看模型构件，请完成以下步骤：
1. 选择管道图中的 Training 步骤。
1. 在右侧边栏选择**概览**选项卡。
1. 在**文件**部分，找到模型构件的 Amazon S3 路径。
1. 要查找模型软件包 ARN，请完成以下步骤：
1. 选择注册模型步骤。
1. 在右侧边栏选择**概览**选项卡。
1. 在**文件**部分，找到模型软件包的 ARN。
------
#### [ Studio Classic ]
**跟踪管道的世系**
1. 登录亚马逊 SageMaker Studio 经典版。有关更多信息，请参阅[启动 Amazon SageMaker Studio 经典版](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html)。
1. 在 Studio 的左侧边栏中，选择**主页**图标 (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/studio/icons/house.png))。
1. 在菜单中，选择**管道**。
1. 使用**搜索**框来筛选管道列表。
1. 选择 `AbalonePipeline` 管道，查看执行列表和管道的其他详细信息。
1. 选择右侧边栏中的 **Property Inspector** 图标 (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/studio/icons/gears.png))，打开**表属性**窗格，在这里可以选择要查看的属性。
1. 选择**设置**选项卡，然后选择**下载管道定义文件**。您可以查看该文件以了解管道图表的定义方式。
1. 在**执行**标签中，选择执行列表中的第一行，查看其执行图和有关执行的其他详细信息。请注意，该图表与教程开头显示的图表相匹配。
使用图表右下方的大小调整图标可以放大或缩小图表，将图表调整到适合屏幕，或将图表扩展到全屏。要聚焦于图表的特定部分，可以选择图表的空白区域，然后拖动图表使其居中。图表右下角的嵌入图显示您在图表中的位置。
![\[\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/yosemite/pipeline-tutorial-execution-graph.png)
1. 在**图表**选项卡上，选择 `AbaloneProcess` 步骤以查看有关该步骤的详细信息。
1. 在**输出**选项卡的**文件**下方找到训练、验证和测试数据集的 Amazon S3 路径。
**注意**
要获取完整路径，请右键单击路径，然后选择**复制单元格内容**。
```
s3://sagemaker-eu-west-1-acct-id/sklearn-abalone-process-2020-12-05-17-28-28-509/output/train
s3://sagemaker-eu-west-1-acct-id/sklearn-abalone-process-2020-12-05-17-28-28-509/output/validation
s3://sagemaker-eu-west-1-acct-id/sklearn-abalone-process-2020-12-05-17-28-28-509/output/test
```
1. 选择 `AbaloneTrain` 步骤。
1. 在**输出**选项卡的**文件**下方找到模型构件的 Amazon S3 路径：
```
s3://sagemaker-eu-west-1-acct-id/AbaloneTrain/pipelines-6locnsqz4bfu-AbaloneTrain-NtfEpI0Ahu/output/model.tar.gz
```
1. 选择 `AbaloneRegisterModel` 步骤。
1. 在**输出**选项卡的**文件**下方找到模型包的 ARN：
```
arn:aws:sagemaker:eu-west-1:acct-id:model-package/abalonemodelpackagegroupname/2
```
------