AWS SageMaker机器学习模型训练与部署全流程指南

1. 为什么选择AWS SageMaker进行模型训练？

当我们需要在云端训练机器学习模型时，AWS SageMaker往往是最先被考虑的平台之一。作为一个完全托管的服务，它解决了传统机器学习工作流中的诸多痛点。想象一下，你不再需要自己搭建和维护GPU服务器集群，不用操心软件环境的兼容性问题，也不必担心训练过程中突然断电导致进度丢失——这些SageMaker都帮你处理好了。

我最初接触SageMaker是在2018年，当时团队正在为一个计算机视觉项目寻找合适的训练平台。我们尝试过自建服务器、用过其他云服务，最终发现SageMaker在易用性和功能完整性上表现最为突出。特别是它的Notebook实例功能，让数据科学家可以像在本地Jupyter Notebook中一样工作，同时又能随时调用强大的云端计算资源。

SageMaker SDK是这一切的核心接口。通过这个Python库，你可以用几行代码就完成从数据准备到模型部署的全流程。比如创建一个训练作业，传统方式可能需要配置EC2实例、安装依赖、设置存储权限等一系列繁琐操作，而在SageMaker中只需要：

python复制from sagemaker.pytorch import PyTorch

estimator = PyTorch(
    entry_script='train.py',
    role='arn:aws:iam::123456789012:role/service-role/AmazonSageMaker-ExecutionRole',
    instance_type='ml.p3.2xlarge',
    framework_version='1.8.0',
    py_version='py36'
)

estimator.fit({'training': 's3://my-bucket/training-data'})

这段代码背后，SageMaker会自动为你：

• 启动一个配置好的GPU实例
• 从S3拉取训练数据
• 设置好PyTorch环境
• 运行你的训练脚本
• 在训练完成后自动关闭实例

这种抽象层级极大地提高了工作效率。根据我的经验，使用SageMaker后，团队从想法到模型的时间缩短了约60%，特别是当需要频繁尝试不同算法和超参数时，这种优势更加明显。

2. 环境准备与SageMaker SDK安装

2.1 AWS账户与权限配置

在开始使用SageMaker之前，我们需要确保AWS账户已正确设置。这包括几个关键步骤：

1. IAM角色创建：这是SageMaker访问其他AWS服务（如S3）的通行证。在IAM控制台中创建一个新角色，选择"SageMaker"作为可信实体，然后附加以下策略：
   • AmazonSageMakerFullAccess
   • AmazonS3FullAccess
   • （可选）AWSCloudFormationFullAccess（如果需要使用SageMaker项目）

重要提示：生产环境中应遵循最小权限原则，而非直接使用FullAccess策略。这里为教学方便采用简化配置。

2. S3存储桶准备：SageMaker使用S3存储训练数据、模型和输出。创建一个专用存储桶，命名如"my-sagemaker-data-2023"（需全局唯一）。建议按用途创建不同前缀：

   • raw-data/ - 原始数据集
   • processed/ - 预处理后的数据
   • models/ - 训练好的模型
   • output/ - 训练日志和输出

3. 区域选择：确认你使用的AWS区域支持SageMaker（大多数商业区域都支持）。不同区域的实例类型可用性和价格可能有差异。我通常选择us-east-1或ap-southeast-1，这两个区域资源较为充足。

2.2 安装与配置SDK

SageMaker SDK可以通过pip直接安装：

bash复制pip install sagemaker

安装后需要进行AWS凭证配置。有几种方式：

方式一：AWS CLI配置（推荐）

bash复制aws configure

按提示输入Access Key ID、Secret Access Key、默认区域等。凭证会保存在~/.aws/credentials中。

方式二：环境变量

bash复制export AWS_ACCESS_KEY_ID="your_access_key"
export AWS_SECRET_ACCESS_KEY="your_secret_key"
export AWS_DEFAULT_REGION="us-east-1"

方式三：在代码中直接指定（不推荐，安全性低）

python复制import boto3

session = boto3.Session(
    aws_access_key_id='your_access_key',
    aws_secret_access_key='your_secret_key',
    region_name='us-east-1'
)

验证安装是否成功：

python复制import sagemaker
print(sagemaker.__version__)  # 应输出如2.173.0等版本号

2.3 开发环境选择

你有多种方式使用SageMaker SDK：

1. 本地开发：在本地Python环境中安装SDK，适合轻量测试和小规模数据。但训练大模型时仍需连接云端资源。

2. SageMaker Notebook实例：AWS提供的托管Jupyter Notebook服务，预装所有依赖。优点是开箱即用，缺点是成本较高（按小时计费）。

3. SageMaker Studio：集成开发环境(IDE)，提供更完整的ML开发体验。适合团队协作和复杂项目。

4. EC2实例：自行配置EC2并安装SDK，灵活性最高但维护成本也高。

对于初学者，我建议从Notebook实例开始。创建步骤：

• 在SageMaker控制台选择"Notebook instances"
• 点击"Create notebook instance"
• 输入名称如"my-first-notebook"
• 选择实例类型（如ml.t3.medium）
• 选择之前创建的IAM角色
• 点击"Create"

约5分钟后实例就绪，可以点击"Open Jupyter"开始使用。

3. 数据准备与上传策略

3.1 数据格式与预处理

SageMaker支持多种数据格式，选择合适的形式能显著提高训练效率。常见格式包括：

1. CSV/TXT：结构化数据的通用选择

   • 优点：人类可读，工具支持广泛
   • 缺点：解析开销大，不支持复杂数据结构

2. RecordIO：AWS优化的二进制格式

   • 优点：I/O效率高，支持流式读取
   • 缺点：需要额外转换步骤

3. TFRecord：TensorFlow原生格式

   • 优点：与TF生态完美集成
   • 缺点：仅适用于TF框架

4. 图像/音频原始文件：直接存储为jpg/png/wav等

   • 优点：无需转换
   • 缺点：元数据管理复杂

我通常的预处理流程：

python复制import pandas as pd
from sklearn.model_selection import train_test_split

# 读取原始数据
data = pd.read_csv('raw_data.csv')

# 清洗与特征工程
data = preprocess(data)

# 划分训练/验证集
train, val = train_test_split(data, test_size=0.2)

# 保存为SageMaker推荐格式
train.to_csv('train/train.csv', index=False)
val.to_csv('validation/validation.csv', index=False)

3.2 高效上传到S3

对于大数据集，直接上传可能非常耗时。这里有几个技巧：

使用AWS CLI多部分上传：

bash复制aws s3 cp --recursive ./train s3://my-bucket/train-data/

启用S3传输加速（跨区域时特别有用）：

bash复制aws configure set default.s3.use_accelerate_endpoint true

并行上传工具（如s5cmd）：

bash复制s5cmd cp --concurrency 100 ./train/* s3://my-bucket/train-data/

监控上传进度：

python复制from tqdm import tqdm
import boto3

s3 = boto3.client('s3')

def upload_with_progress(local_path, bucket, key):
    total_size = os.path.getsize(local_path)
    with tqdm(total=total_size, unit='B', unit_scale=True) as pbar:
        s3.upload_file(
            local_path, bucket, key,
            Callback=lambda bytes_transferred: pbar.update(bytes_transferred)
        )

3.3 数据访问模式

SageMaker提供三种主要数据访问方式：

1. 文件模式：训练实例直接访问S3文件

   • 适用场景：小数据集，简单模型
   • 示例URI：s3://my-bucket/train-data/

2. 管道模式：数据通过高性能管道流式传输

   • 适用场景：大数据集，需要快速启动
   • 示例URI：s3://my-bucket/train-data/pipe

3. 快速文件模式：缓存数据到实例存储

   • 适用场景：需要重复访问相同数据
   • 示例URI：s3://my-bucket/train-data/fastfile

选择建议：

• 数据集<1GB → 文件模式
• 1GB-100GB → 管道模式

• 100GB或需要多次访问 → 快速文件模式

4. 训练任务配置与启动

4.1 选择训练实例

SageMaker提供丰富的实例类型，主要分为几类：

选择建议：

• 首次尝试 → ml.m5.large
• 中小规模图像模型 → ml.g4dn.xlarge
• 大语言模型 → ml.p3dn.24xlarge
• 极致性价比 → ml.trn1.32xlarge

实测经验：

• 对于ResNet50在ImageNet上的训练，ml.p3.2xlarge比ml.g4dn.xlarge快约3倍，但成本高4倍
• 使用Spot实例可以节省60-90%成本，但可能被中断
• 训练集群可以自动扩展，但需要额外配置

4.2 配置训练作业

一个完整的训练作业配置示例：

python复制from sagemaker.pytorch import PyTorch

estimator = PyTorch(
    entry_script='train.py',
    source_dir='src',
    dependencies=['requirements.txt'],
    role='arn:aws:iam::123456789012:role/service-role/AmazonSageMaker-ExecutionRole',
    instance_count=2,
    instance_type='ml.p3.2xlarge',
    framework_version='1.12.0',
    py_version='py38',
    hyperparameters={
        'epochs': 50,
        'batch-size': 128,
        'learning-rate': 0.001
    },
    output_path='s3://my-bucket/output',
    code_location='s3://my-bucket/code',
    use_spot_instances=True,
    max_wait=3600,
    max_run=3000,
    environment={
        'SM_CHANNEL_TRAIN': '/opt/ml/input/data/train',
        'SM_MODEL_DIR': '/opt/ml/model'
    }
)

关键参数解析：

• entry_script：训练脚本入口文件
• source_dir：包含额外源代码的目录
• instance_count：实例数量（分布式训练）
• use_spot_instances：是否使用Spot实例节省成本
• environment：传递给训练脚本的环境变量

4.3 启动与监控训练

启动训练作业：

python复制estimator.fit({
    'train': 's3://my-bucket/train-data',
    'validation': 's3://my-bucket/val-data'
})

监控训练进度有多种方式：

1. SageMaker控制台

• 实时查看CPU/GPU利用率
• 查看CloudWatch日志
• 监控指标图表

2. 在Notebook中直接查询

python复制import pandas as pd

metrics = estimator.training_job_analytics.dataframe()
print(metrics[metrics.metric_name == 'train:accuracy'])

3. 使用CloudWatch API

python复制import boto3
import matplotlib.pyplot as plt

cw = boto3.client('cloudwatch')

def plot_metric(job_name, metric):
    response = cw.get_metric_statistics(
        Namespace='AWS/SageMaker',
        MetricName=metric,
        Dimensions=[{'Name': 'TrainingJobName', 'Value': job_name}],
        StartTime=estimator.latest_training_job.start_time,
        EndTime=estimator.latest_training_job.end_time,
        Period=60,
        Statistics=['Average']
    )
    
    df = pd.DataFrame(response['Datapoints'])
    plt.plot(df['Timestamp'], df['Average'])
    plt.title(metric)
    plt.show()

plot_metric(estimator.latest_training_job.name, 'train:loss')

常见问题处理：

• 训练卡在"Starting"状态 → 检查IAM权限
• 实例无法启动 → 检查区域可用性
• GPU利用率低 → 优化数据管道或增大batch size
• 内存不足 → 减小batch size或换更大实例

5. 模型部署与推理优化

5.1 部署基础端点

训练完成后，部署模型只需几行代码：

python复制predictor = estimator.deploy(
    initial_instance_count=1,
    instance_type='ml.m5.large',
    endpoint_name='my-model-endpoint'
)

这会在后台：

1. 创建SageMaker模型实体
2. 配置端点配置
3. 启动推理实例
4. 部署容器

端点配置选项：

• initial_instance_count：实例数量（用于扩展）
• instance_type：推理实例类型
• model_data_download_timeout：大模型下载超时设置
• volume_size：附加存储大小（GB）
• data_capture_config：启用推理数据捕获

5.2 高级部署模式

1. 自动扩展配置

python复制from sagemaker.production_variant import ProductionVariant

production_variant = ProductionVariant(
    'my-model-variant',
    'ml.m5.large',
    1,
    initial_weight=1,
    variant_name='AllTraffic'
)

predictor = estimator.deploy(
    production_variants=[production_variant],
    auto_scaling_config={
        'MinCapacity': 1,
        'MaxCapacity': 10,
        'TargetValue': 70.0,  # CPU利用率70%
        'ScaleInCooldown': 300,
        'ScaleOutCooldown': 60
    }
)

2. 多模型端点

python复制from sagemaker.multidatamodel import MultiDataModel

mme = MultiDataModel(
    name='my-multi-model',
    model_data_prefix='s3://my-bucket/models/',
    model=estimator.model_data,
    sagemaker_session=sagemaker.Session()
)

mme.add_model(model_data_source='s3://my-bucket/models/model1.tar.gz', model_data_path='model1')
mme.add_model(model_data_source='s3://my-bucket/models/model2.tar.gz', model_data_path='model2')

predictor = mme.deploy(
    initial_instance_count=1,
    instance_type='ml.m5.large'
)

3. 渐进式部署（蓝绿部署）

python复制from sagemaker.model_monitor import DataCaptureConfig

# 创建新配置
new_config = sagemaker.session.session._create_endpoint_config(
    'new-config',
    [{
        'InstanceType': 'ml.m5.large',
        'InitialInstanceCount': 1,
        'ModelName': estimator.model_data,
        'VariantName': 'new-variant'
    }],
    data_capture_config=DataCaptureConfig(
        enable_capture=True,
        sampling_percentage=100
    )
)

# 更新端点
sagemaker.session.session.update_endpoint(
    endpoint_name='my-model-endpoint',
    endpoint_config_name='new-config'
)

5.3 推理优化技巧

1. 批处理预测

python复制transformer = estimator.transformer(
    instance_count=1,
    instance_type='ml.m5.large',
    strategy='MultiRecord',
    max_payload=10,  # MB
    max_concurrent_transforms=4
)

transformer.transform(
    data='s3://my-bucket/input-data',
    content_type='text/csv',
    split_type='Line'
)

2. 模型压缩

python复制from sagemaker.compression import Compression

compressed_model = Compression(
    base_model=estimator.model_data,
    compression_type='INT8',
    framework='pytorch'
).compress()

compressed_predictor = compressed_model.deploy(...)

3. 使用Inference Recommender

python复制from sagemaker.inference_recommender import InferenceRecommender

recommender = InferenceRecommender(
    role='arn:aws:iam::123456789012:role/service-role/AmazonSageMaker-ExecutionRole',
    instance_types=['ml.m5.large', 'ml.g4dn.xlarge'],
    traffic_pattern={
        'Phases': [
            {'InitialNumberOfUsers': 1, 'SpawnRate': 1, 'DurationInSeconds': 60},
            {'InitialNumberOfUsers': 10, 'SpawnRate': 2, 'DurationInSeconds': 120}
        ]
    }
)

recommendations = recommender.get_recommendations(
    model_name=estimator.model_data,
    workload_type='RealTime'
)

6. 成本优化与最佳实践

6.1 成本控制策略

1. Spot实例使用

python复制estimator = PyTorch(
    ...,
    use_spot_instances=True,
    max_wait=3600,  # 最大等待时间(秒)
    max_run=1800    # 实际运行时间上限
)

2. 自动停止闲置端点

python复制from sagemaker.autoshutdown import AutoShutdown

autoshutdown = AutoShutdown(
    endpoint_name='my-model-endpoint',
    idle_time_seconds=3600  # 1小时无请求后停止
)

3. 成本监控

bash复制aws budgets create-budget \
    --account-id 123456789012 \
    --budget '{
        "BudgetName": "sagemaker-monthly",
        "BudgetLimit": {"Amount": "100", "Unit": "USD"},
        "CostFilters": {"Service": "Amazon SageMaker"},
        "TimeUnit": "MONTHLY"
    }'

6.2 性能优化技巧

1. 数据管道优化

python复制from sagemaker.tensorflow import TensorFlow

estimator = TensorFlow(
    ...,
    input_mode='Pipe',
    training_input_mode='Pipe'
)

2. 分布式训练配置

python复制estimator = PyTorch(
    ...,
    distribution={
        'smdistributed': {
            'dataparallel': {
                'enabled': True
            }
        },
        'mpi': {
            'enabled': True,
            'processes_per_host': 4
        }
    }
)

3. 混合精度训练

python复制estimator = PyTorch(
    ...,
    environment={
        'SM_FRAMEWORK_PARAMS': '{"fp16": {"enabled": true}}'
    }
)

6.3 安全最佳实践

1. 网络隔离

python复制from sagemaker.network import NetworkConfig

network_config = NetworkConfig(
    enable_network_isolation=True,
    encrypt_inter_container_traffic=True,
    security_group_ids=['sg-123456'],
    subnets=['subnet-123456']
)

estimator = PyTorch(
    ...,
    network_config=network_config
)

2. 数据加密

python复制from sagemaker.encryption import EncryptionConfig

encryption_config = EncryptionConfig(
    volume_kms_key='arn:aws:kms:us-east-1:123456789012:key/abcd1234',
    output_kms_key='arn:aws:kms:us-east-1:123456789012:key/efgh5678'
)

estimator = PyTorch(
    ...,
    encryption_config=encryption_config
)

3. IAM最小权限

json复制{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::my-bucket",
                "arn:aws:s3:::my-bucket/*"
            ]
        }
    ]
}

7. 实战案例：图像分类模型全流程

7.1 项目概述

我们以CIFAR-10图像分类为例，展示完整的SageMaker工作流。目标是在云端训练一个能识别10类物体的模型，并部署为可调用的API。

7.2 数据准备

python复制import torchvision
import torchvision.transforms as transforms
import os

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = torchvision.datasets.CIFAR10(
    root='./data', train=True, download=True, transform=transform
)
testset = torchvision.datasets.CIFAR10(
    root='./data', train=False, download=True, transform=transform
)

# 保存为SageMaker需要的格式
os.makedirs('train', exist_ok=True)
os.makedirs('validation', exist_ok=True)

for i, (image, label) in enumerate(trainset):
    torch.save({'image': image, 'label': label}, f'train/{i}.pt')
    
for i, (image, label) in enumerate(testset):
    torch.save({'image': image, 'label': label}, f'validation/{i}.pt')

# 上传到S3
!aws s3 cp --recursive ./train s3://my-bucket/cifar10/train/
!aws s3 cp --recursive ./validation s3://my-bucket/cifar10/validation/

7.3 训练脚本编写

train.py主要内容：

python复制import argparse
import os
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

class CIFARDataset(Dataset):
    def __init__(self, channel_dir):
        self.files = [os.path.join(channel_dir, f) for f in os.listdir(channel_dir)]
        
    def __len__(self):
        return len(self.files)
    
    def __getitem__(self, idx):
        data = torch.load(self.files[idx])
        return data['image'], data['label']

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = torch.flatten(x, 1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--epochs', type=int, default=10)
    parser.add_argument('--batch-size', type=int, default=32)
    parser.add_argument('--learning-rate', type=float, default=0.001)
    args = parser.parse_args()
    
    train_dataset = CIFARDataset(os.environ['SM_CHANNEL_TRAIN'])
    val_dataset = CIFARDataset(os.environ['SM_CHANNEL_VALIDATION'])
    
    train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)
    val_loader = DataLoader(val_dataset, batch_size=args.batch_size)
    
    model = Net()
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=args.learning_rate)
    
    for epoch in range(args.epochs):
        model.train()
        for inputs, labels in train_loader:
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
        
        model.eval()
        val_loss = 0.0
        correct = 0
        total = 0
        with torch.no_grad():
            for inputs, labels in val_loader:
                outputs = model(inputs)
                loss = criterion(outputs, labels)
                val_loss += loss.item()
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()
        
        print(f'Epoch {epoch+1}, Val Loss: {val_loss/len(val_loader):.4f}, Accuracy: {100*correct/total:.2f}%')
    
    torch.save(model.state_dict(), os.path.join(os.environ['SM_MODEL_DIR'], 'model.pth'))

7.4 启动训练作业

python复制from sagemaker.pytorch import PyTorch

estimator = PyTorch(
    entry_script='train.py',
    role='arn:aws:iam::123456789012:role/service-role/AmazonSageMaker-ExecutionRole',
    instance_type='ml.g4dn.xlarge',
    instance_count=1,
    framework_version='1.12.0',
    py_version='py38',
    hyperparameters={
        'epochs': 20,
        'batch-size': 128,
        'learning-rate': 0.01
    }
)

estimator.fit({
    'train': 's3://my-bucket/cifar10/train',
    'validation': 's3://my-bucket/cifar10/validation'
})

7.5 部署与测试

python复制predictor = estimator.deploy(
    initial_instance_count=1,
    instance_type='ml.m5.large',
    endpoint_name='cifar10-classifier'
)

# 测试推理
import numpy as np
from PIL import Image

img = Image.open('test_image.jpg').resize((32, 32))
img_array = np.array(img).transpose(2, 0, 1).astype(np.float32)
img_array = (img_array / 255.0 - 0.5) / 0.5  # 与训练相同的归一化

result = predictor.predict(img_array[None, ...])
predicted_class = np.argmax(result)
print(f'Predicted class: {predicted_class}')

8. 调试与问题排查

8.1 常见错误与解决方案

问题1：训练作业卡在"Starting"状态

• 可能原因：IAM权限不足
• 检查：确保执行角色有sagemaker:CreateTrainingJob权限
• 验证：

python复制import boto3
sts = boto3.client('sts')
print(sts.get_caller_identity())

问题2：GPU利用率低

• 可能原因：数据加载瓶颈
• 解决方案：
  • 使用Pipe模式
  • 增加数据加载workers
  • 使用更快的存储如EFS

问题3：内存不足(OOM)错误

• 调整方案：
  • 减小batch size
  • 使用梯度累积
  • 换用更大内存实例

8.2 日志查看技巧

CloudWatch日志位置：

code复制/aws/sagemaker/TrainingJobs
/aws/sagemaker/Endpoints

在Notebook中直接查看：

python复制from IPython.display import display, HTML

def show_logs(job_name):
    logs = estimator.logs()
    display(HTML(f'<pre>{logs}</pre>'))

show_logs(estimator.latest_training_job.name)

过滤关键错误：

python复制import boto3

logs = boto3.client('logs')
response = logs.filter_log_events(
    logGroupName='/aws/sagemaker/TrainingJobs',
    logStreamName=estimator.latest_training_job.name + '/algo-1-123456',
    filterPattern='?ERROR ?Error ?error'
)

for event in response['events']:
    print(event['message'])

8.3 性能调优工具

SageMaker Debugger：

python复制from sagemaker.debugger import Rule, rule_configs

rules = [
    Rule.sagemaker(rule_configs.vanishing_gradient()),
    Rule.sagemaker(rule_configs.loss_not_decreasing()),
    Rule.sagemaker(rule_configs.overtraining())
]

estimator = PyTorch(
    ...,
    rules=rules,
    debugger_hook_config=DebuggerHookConfig(
        s3_output_path='s3://my-bucket/debug-output'
    )
)

Profiler报告：

python复制from sagemaker.profiler import ProfilerConfig

profiler_config = ProfilerConfig(
    system_monitor_interval_millis=500,
    framework_profile_params=FrameworkProfile(
        local_path='/opt/ml/output/profiler',
        start_step=5,
        num_steps=10
    )
)

estimator = PyTorch(
    ...,
    profiler_config=profiler_config
)

训练完成后下载报告：

bash复制aws s3 cp s3://my-bucket/debug-output ./debug-output --recursive

9. 进阶功能探索

9.1 使用SageMaker Experiments管理实验

python复制from sagemaker.experiments import Experiment

exp = Experiment.create(
    experiment_name='cifar10-hyperparam-tuning',
    description='Testing different learning rates'
)

for lr in [0.1, 0.01, 0.001]:
    with exp.run(f'lr-{lr}') as run:
        estimator = PyTorch(
            ...,
            hyperparameters={
                'learning-rate': lr,
                ...
            }
        )
        
        estimator.fit(...)
        
        run.log_parameter('learning_rate', lr)
        run.log_metric('val_accuracy', estimator.training_job_analytics.dataframe()['value'].max())

9.2 自动模型调优

python复制from sagemaker.tuner import HyperparameterTuner, ContinuousParameter

hyperparameter_ranges = {
    'learning-rate': ContinuousParameter(0.001, 0.1),
    'batch-size': IntegerParameter(32, 256),
    'epochs': IntegerParameter(5, 20)
}

tuner = HyperparameterTuner(
    estimator=estimator,
    objective_metric_name='val:accuracy',
    objective_type='Maximize',
    hyperparameter_ranges=hyperparameter_ranges,
    max_jobs=20,
    max_parallel_jobs=4
)

tuner.fit({
    'train': 's3://my-bucket/train',
    'validation': 's3://my-bucket/validation'
})

9.3 使用SageMaker Pipelines构建ML工作流

python复制from sagemaker.workflow.pipeline import Pipeline
from sagemaker.workflow.steps import TrainingStep, ProcessingStep

# 定义预处理步骤
preprocess_step = ProcessingStep(
    name="PreprocessData",
    processor=SKLearnProcessor(
        framework_version='0.23-1',
        instance_type='ml.m5.xlarge',
        instance_count=1,
        role=role
    ),
    code='preprocess.py',
    outputs=[
        ProcessingOutput(
            output_name='train',
            source='/opt/ml/processing/train',
            destination='s3://my-bucket/processed/train'
        ),
        ProcessingOutput(
            output_name='validation',
            source='/opt/ml/processing/validation',
            destination='s3://my-bucket/processed/validation'
        )
    ]
)

# 定义训练步骤
train_step = TrainingStep(
    name="TrainModel",
    estimator=estimator,
    inputs={
        'train': preprocess_step.properties.ProcessingOutputConfig.Outputs['train'].S3Output.S3Uri,
        'validation': preprocess_step.properties.ProcessingOutputConfig.Outputs['validation'].S3Output.S3Uri
    }
)

# 创建并运行管道
pipeline = Pipeline(
    name='CIFAR10-Pipeline',
    steps=[preprocess_step, train_step],
    sagemaker_session=sagemaker.Session()
)

pipeline.upsert(role_arn=role)
execution = pipeline.start()

9.4 使用SageMaker JumpStart快速开始

python复制from sagemaker.jumpstart.model import JumpStartModel

model = JumpStartModel(
    model_id='pytorch-ic-resnet50',
    model_version='1.0.0',
    role=role
)

predictor = model.deploy(
    initial_instance_count=1,
    instance_type='ml.m5.large'
)

10. 从开发到生产的完整生命周期

10.1 模型版本控制

python复制from sagemaker.model import ModelPackage

model_package = ModelPackage(
    role=role,
    model_data=estimator.model_data,
    source_algorithm=estimator.latest_training_job.algorithm_arn,
    approval_status='Approved',
    model_package_name='cifar10-classifier',
    model_package_group_name='cifar10-models',
    model_package_version='1.0.0'
)

model_package.create()

10.2 模型监控与漂移检测

python复制from sagemaker.model_monitor import DataCaptureConfig, ModelMonitor

# 配置数据捕获
data_capture_config = DataCaptureConfig(
    enable_capture=True,
    sampling_percentage=100,
    destination_s3_uri='s3://my-bucket/data-capture',
    capture_options=['REQUEST', 'RESPONSE']
)

predictor = estimator.deploy(
    ...,
    data_capture_config=data_capture_config
)

# 设置监控
monitor = ModelMonitor(
    role=role,
    baseline_dataset='s3://my-bucket/baseline.csv',
    output_s3_uri='s3://my-bucket/monitoring-reports',
    schedule_cron_expression='cron(0 * ? * * *)'  # 每小时一次
)

monitor.create_monitoring_schedule(
    endpoint_input=predictor.endpoint_name
)

10.3 CI/CD集成

AWS CodePipeline示例：

yaml复制name: ml-pipeline
version: 0.2
stages:
  - name: Source
    actions:
      - name: SourceAction
        actionTypeId:
          category: Source
          owner: AWS
          version: 1
          provider: CodeCommit
        configuration:
          RepositoryName: ml-repo
          BranchName: main
        outputArtifacts:
          - name: SourceOutput
  - name: Train
    actions:
      - name: TrainingAction
        actionTypeId:
          category