使用AWS SageMaker进行机器学习项目
本文主要介绍如何使用AWS SageMaker进行机器学习项目。
1. 题目
使用的题目为阿里天池的“工业蒸汽量预测“，题目地址为：
https://tianchi.aliyun.com/competition/entrance/231693/introduction
给定的数据: 脱敏后的锅炉传感器采集的数据（采集频率为分钟级）
预测目标: 根据锅炉的工况，预测产生的蒸汽量。
数据说明: 数据分成训练数据（train.txt）和测试数据（test.txt），其中字段”V0”-“V37”，这38个字段是作为特征变量，”target”作为目标变量。选手利用训练数据训练出模型，预测测试数据的目标变量，排名结果依据预测结果的MSE（mean square error）。
结果评估: 预测结果以mean square error作为评判标准。
2. AWS SageMaker
AWS SageMaker是亚马逊云科技提供的机器学习服务，它整合了专门为ML可用的功能集，帮助数据科学家和开发人员快速准备、构建、训练和部署高质量的机器学习模型。
我们首先使用的是 AWS SageMaker的Notebook Instance进行数据的探索、清洗以及准备。在Notebook Instance中运行了一个Jupyter notebook server，可以在其上编写代码并做相关测试。例如：
在Jupyter中创建一个conda_python3 的notebook，即可开始对数据进行探索与处理。
3. 数据探索
3.1. 初步探索
先简单查看一下数据：
import pandas as pd import s3fs import matplotlib.pyplot as plt import numpy as np import seaborn as sns from scipy import stats plt.style.use('seaborn') %matplotlib inline train_raw = pd.read_csv(train_data_uri, sep=' ', encoding='utf-8') test_raw = pd.read_csv(test_data_uri, sep=' ', encoding='utf-8') train_raw.head()
train_raw.info() <class 'pandas.core.frame.DataFrame'> RangeIndex: 2888 entries, 0 to 2887 Data columns (total 39 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 V0 2888 non-null float64 1 V1 2888 non-null float64 2 V2 2888 non-null float64 … 37 V37 2888 non-null float64 38 target 2888 non-null float64 dtypes: float64(39) memory usage: 880.1 KB
从训练集 info 信息我们可以知道，在训练集中：
- 一共有2888 个样本， 38个字段（V0 - V37） ，1个 target
- 所有特征均为连续型特征
- Label为连续型，所以我们需要回归函数进行预测
- 所有特征均没有空置
测试集 info()：
test_raw.info() <class 'pandas.core.frame.DataFrame'> RangeIndex: 1925 entries, 0 to 1924 Data columns (total 38 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 V0 1925 non-null float64 1 V1 1925 non-null float64 2 V2 1925 non-null float64 … 36 V36 1925 non-null float64 37 V37 1925 non-null float64 dtypes: float64(38) memory usage: 571.6 KB
从测试集info() 我们可以了解到，在测试集中：
- 一共有1925个样本，38个字段（V0 - V37）
- 所有特征均为连续型
- 没有缺失值
若是进一步对df 做 describe()，则会有 39 个字段的describe数据，从观察数据的角度来看，比较复杂，所以下一步我们对数据进行可视化。
3.2. 数据可视化
3.2.1. 盒图
首先我们通过boxplot 探索离群点，首先以特征V1为例：
fig = plt.figure(figsize=(4, 6)) sns.boxplot(train_raw[['V1']], orient='v', width=0.5, palette="Set3")
可以看到此特征有非常多的离群点。然后我们将所有特征进行盒图可视化：
# boxplot for all features columns = train_raw.columns[:-1] fig = plt.figure(figsize=(80, 100), dpi=75) for i in range(len(columns)): plt.subplot(7, 6, i+1) sns.boxplot(train_raw[columns[i]], orient='v', width=0.5, palette="Set3") plt.ylabel(columns[i]) plt.show()
部分结果如下：
从这个结果来看，大部分特征或多或少均存在离群点，后续在特征工程阶段需要对此进行进一步处理。
3.2.2. 直方图与Q-Q图
接下来探索数据的分布情况，是否为正态分布。通过直方图与Q-Q图进行探索。
先以V0 特征为例：
plt.figure(figsize=(10, 5)) ax1 = plt.subplot(121) sns.distplot(train_raw['V0'], fit=stats.norm) ax2 = plt.subplot(122) res = stats.probplot(train_raw['V0'], plot=plt)
可以看到训练集中V0 特征并非为正态分布。接下来我们绘制所有特征的直方图与Q-Q图：
import warnings warnings.filterwarnings("ignore") plt.figure(figsize=(80, 190)) ax_index = 1 for i in range(len(columns)): ax = plt.subplot(19, 4, ax_index) sns.distplot(train_raw[columns[i]], fit=stats.norm) ax_index += 1 ax = plt.subplot(19, 4, ax_index) res = stats.probplot(train_raw[columns[i]], plot=plt) ax_index += 1
部分结果如下：
可以看到其中有的特征符合正态分布，但大部分并不符合，数据并不跟随对角线分布。对此，后续可以使用数据变换对其进行处理。
3.2.3. KDE分布图
KDE（Kernel Density Estimation，核密度估计）可以理解为是对直方图的加窗平滑。我们可以通过此图比较直观的看出数据本身的分布特征。
这里我们通过绘制KDE图，查看并对比训练集和测试集中特征变量的分布情况，来发现两个数据集中分布不一致的特征变量。
先仍以特征V0为例：
plt.figure(figsize=(10, 8)) ax = sns.kdeplot(train_raw['V0'], color="Red", shade=True) ax = sns.kdeplot(test_raw['V0'], color="Blue", shade=True) ax.set_xlabel("V0") ax.set_ylabel("Frequency") ax.legend(['train', 'test'])
可以看到 V0 在两个数据集中的分布基本一致。然后对所有特征画出训练集与测试集中的KDE分布：
# all features' kde plots plt.figure(figsize=(40, 100)) ax_index = 1 for i in range(len(columns)): ax = plt.subplot(10, 4, ax_index) ax = sns.kdeplot(train_raw[columns[i]], color="Red", shade=True) ax = sns.kdeplot(test_raw[columns[i]], color="Blue", shade=True) ax.set_xlabel(columns[i]) ax.set_ylabel("Frequency") ax.legend(['train', 'test']) ax_index += 1
可以看到大部分特征的分布在训练集与测试集中基本一致，但仍有几个特征的分布在两个数据集中不一致（主要为V5、V9、V11、V17、V22、V28），这样会导致模型的泛化能力变差，可以考虑删除这些特征。
3.2.4. 线性回归关系图
线性回归关系图主要用于分析特征与label之间的线性相关性。
先看特征V0 与label的线性相关性：
plt.figure(figsize=(10, 8)) ax = plt.subplot(121) sns.regplot(x='V0', y='target', data=train_raw, ax=ax, scatter_kws={'marker':'.', 's':4, 'alpha':0.3}, line_kws={'color':'g'}) plt.xlabel('V0') plt.ylabel('target') plt.show()
从plot结果来看，可以看到V0特征与label是存在一定的相关性。接下来 plot所有特征与label的相关性：
plt.figure(figsize=(16, 32)) for i in range(len(columns)): ax = plt.subplot(10, 4, i+1) sns.regplot(x=columns[i], y='target', data=train_raw, ax=ax, scatter_kws={'marker':'.', 's':4, 'alpha':0.3}, line_kws={'color':'g'}) ax.set_xlabel(columns[i]) ax.set_ylabel('target')
部分结果如下所示：
从结果来看，有不少特征与label有较强相关性（例如V0，V1，V8，V27，V31，…等），但是仍有部分特征与label之间基本无相关性（例如V9，V10，V13，V14，…等）。
当然这里只检查的是线性相关，并非表示特征与label之间没有其他相关性（例如非线性相关性）。
3.2.5. 线性相关性与热力图
变量之间的相关性通过协方差矩阵进行衡量，首先计算协方差矩阵并按与target相关性高低进行排序：
train_corr = train_raw.corr() abs(train_corr['target']).sort_values(ascending=False, inplace=False) target 1.000000 V0 0.873212 V1 0.871846 V8 0.831904 ... V21 0.010063 V14 0.008424 V34 0.006034 Name: target, dtype: float64
可以看到与label的相关性低于0.1 的特征有：V33，V32，V26，V25，V21，V14，V34。
通过热力图可视化：
筛选出与label相关性大于0.1的特征：
corr_columns = train_corr[abs(train_corr['target']) > 0.1]['target'].index.tolist()[:-1] ['V0', 'V1', 'V2', ...'V37']
4. 特征工程
根据数据探索过程中观察到的现象，现在对数据做第一次特征处理。
4.1. 离群点
之前在boxplot中可以看到大部分特征存在离群点，一般会对离群点的处理是进行删除。不过在这个数据集中，删除过多的数据条目是不可接受的，所以我们会手动定义一个更大的范围，用于过滤离群点。
首先绘出所有特征的boxplot：
plt.figure(figsize=(36, 20)) green_diamond = dict(markerfacecolor='g', marker='o') plt.boxplot(train_raw.T, labels=train_raw.columns, showbox=True, showfliers=True, patch_artist=True, flierprops=green_diamond) plt.show()
从图中能看到偏离较大的是V9的特征，这里从保守的角度，保留[-7.5, +7.5] 之间的数据。
train_drop_outlier = train_raw[train_raw['V9'] > -7.5] test_drop_outlier = test_raw[test_raw['V9'] > -7.5]
4.2. 剔除特征
通过KDE分布图，可以找到几个特征在训练集与测试集中的分布不一致，会导致模型的泛化能力变差，所以删除V5、V9、V11、V17、V22、V28这几个特征。
train_dropped_feature = train_drop_outlier.drop(['V5', 'V9', 'V11', 'V17', 'V22', 'V28'], axis=1) test_dropped_feature = test_drop_outlier.drop(['V5', 'V9', 'V11', 'V17', 'V22', 'V28'], axis=1)
4.3. 归一化
由于各个特征的取值范围并不一致，需要对所有数值类型做归一化：
# min_max_scaler from sklearn.preprocessing import MinMaxScaler # target feature does not need to be scaled train_dropped_target = train_dropped_feature.drop(['target'], axis=1) feature_columns = train_dropped_target.columns.tolist() # min_max_scale fit on trainging data min_max_scaler = MinMaxScaler().fit(train_dropped_target) # min_max scale transform on both training and test data train_scaled = min_max_scaler.transform(train_dropped_target) test_scaled = min_max_scaler.transform(test_dropped_feature) train_scaled = pd.DataFrame(train_scaled, columns=feature_columns) train_scaled['target'] = train_dropped_feature['target'] test_scaled = pd.DataFrame(test_scaled, columns=feature_columns)
4.4. PCA降维
PCA降维除了用于减少数据维度外，还能够去除数据的多重性。下面使用PCA处理，保留95％的信息：
# PCA from sklearn.decomposition import PCA pca = PCA(n_components=0.99) train_pca_99 = pca.fit_transform(train_scaled.iloc[:,0:-1]) test_pca_99 = pca.transform(test_scaled) train_pca_99 = pd.DataFrame(train_pca_99) train_pca_99['target'] = train_dropped_feature['target'] test_pca_99 = pd.DataFrame(test_pca_99)
5. 模型训练
在数据进行了预处理后，下面即可开始使用模型进行训练。首先切分train_pca_99为训练集、验证集和测试集：
# train test split from sklearn.model_selection import train_test_split train_pca_99 = train_pca_99.dropna() train_data_fin = train_pca_99.drop(['target'], axis=1) train_data_fin_target = train_pca_99['target'] train_data, test_data, train_target, test_target = train_test_split(train_data_fin, train_data_fin_target, test_size=0.2) print(train_data.shape, test_data.shape, train_target.shape, test_target.shape) (2307, 25) (577, 25) (2307,) (577,)
6. 集成模型
在完成一个机器学习项目时，一般不会仅使用单个模型完成预测，而是使用多个模型的结果进行集成。当前几个主流的集成方法包括：Bagging，Boosting以及Stacking。在这个例子中，我们会使用Bagging，通过SageMaker分别训练一个XGBoost 和一个LinearLeaner，然后在预测时，使用它们的平均值作为预测输出。
6.1. XGBoost
在SageMaker中，对于XGBoost模型训练的输入规则是：
- 对于训练 ContentType，有效输入是 text/libsvm（默认值）或 text/csv
- 对于 CSV 训练，算法假定目标变量在第一列中，而 CSV 没有标头记录。
所以我们需要先将label列作为训练数据的第一列，并写为一个csv文件，再上传到s3，代码如下：
# put label at the first col train_data.insert(0, 'target', train_target) # split train_data into data_train and data_val train_list = np.random.rand(len(train_data)) < 0.8 data_train = train_data[train_list] data_val = train_data[~train_list] # save them locally data_train.to_csv("formatted_train.csv", sep=',', header=False, index=False) # save training data data_val.to_csv("formatted_val.csv", sep=',', header=False, index=False) # save validation data test_data.to_csv("formatted_test.csv", sep=',', header=False, index=False) # save test data # upload to s3 import os bucket = 'tang-sagemaker' prefix = 'ZhengQi_data' train_file = 'formatted_train.csv' val_file = 'formatted_val.csv' boto3.Session().resource('s3').Bucket(bucket).Object(os.path.join(prefix, 'train/', train_file)).upload_file(train_file) boto3.Session().resource('s3').Bucket(bucket).Object(os.path.join(prefix, 'val/', val_file)).upload_file(val_file)
指定训练参数并进行训练：
# another approach # training from sagemaker import get_execution_role import sagemaker role = get_execution_role() sess = sagemaker.Session() s3_output_location = f's3://{bucket}/{prefix}/output/' train_channel = sagemaker.inputs.TrainingInput(f's3://{bucket}/{prefix}/train/formatted_train.csv', content_type='text/csv') val_channel = sagemaker.inputs.TrainingInput(f's3://{bucket}/{prefix}/val/formatted_val.csv', content_type='text/csv') container = sagemaker.image_uris.retrieve('xgboost', 'cn-north-1', 'latest') xgb_model = sagemaker.estimator.Estimator(container, role, instance_count=1, instance_type='ml.m4.xlarge', volume_size = 5, output_path=s3_output_location, sagemaker_session=sagemaker.Session(), enable_sagemaker_metrics=False) xgb_model.set_hyperparameters( max_depth = 5, gamma = 1, min_child_weight = 1, objective = 'reg:squarederror', eval_metric = 'rmse', num_round = 100, early_stopping_rounds=10 ) xgb_model.fit({'train': train_channel, 'validation':val_channel})
以此参数进行训练后的结果为：
[24]#011train-rmse:0.311867#011validation-rmse:0.530562
Stopping. Best iteration:
[14]#011train-rmse:0.32222#011validation-rmse:0.528132
可以看到最低的rmse结果为0.5281。
6.1.1. XGBoost超参数调优
在进行超参数调优时，可以启动一个超参数优化任务。原理与sklearn中的超参数搜索（例如GridSearch，RandomeizedSearch等）类似。这里我们选择随机超参数搜索，代码如下：
from sagemaker.tuner import ContinuousParameter, HyperparameterTuner objective_metric_name = 'validation:rmse' hyperparameter_ranges = { 'alpha': ContinuousParameter(0.01, 10, scaling_type="Logarithmic"), 'lambda': ContinuousParameter(0.01, 10, scaling_type="Logarithmic") } tuner_log = HyperparameterTuner( xgb_model, objective_metric_name, hyperparameter_ranges, objective_type='Minimize', max_jobs=20, max_parallel_jobs=10, strategy='Random' ) tuner_log.fit({'train': train_channel, 'validation': val_channel}, include_cls_metadata=False)
探索结果：
df_log = sagemaker.HyperparameterTuningJobAnalytics(tuner_log.latest_tuning_job.job_name).dataframe() df_log['FinalObjectiveValue'].sort_values(ascending=True, inplace=False)[:3] 11 0.523109 18 0.524432 10 0.525883 Name: FinalObjectiveValue, dtype: float64 df_log.loc[11] alpha 0.0187497 lambda 5.70063 TrainingJobName xgboost-210409-1554-009-70f060d0 TrainingJobStatus Completed FinalObjectiveValue 0.523109 TrainingStartTime 2021-04-09 15:58:27+00:00 TrainingEndTime 2021-04-09 15:59:34+00:00 TrainingElapsedTimeSeconds 67 scaling log Name: 11, dtype: object
可以看到在这次超参数搜索中，排名最好的alpha和lambda参数组为：
alpha 0.0187497
lambda 5.70063
对应的训练job为：xgboost-210409-1554-009-70f060d0
6.1.2. XGBoost模型部署
创建此训练job对应的模型：
# create model sm = boto3.client('sagemaker') best_xgboost_model = df_log.loc[df_log['FinalObjectiveValue'].idxmin()]['TrainingJobName'] model_name=best_xgboost_model + '-mdl' xgboost_hosting_container = { 'Image': container, 'ModelDataUrl': sm.describe_training_job(TrainingJobName=best_xgboost_model)['ModelArtifacts']['S3ModelArtifacts'] } create_model_response = sm.create_model( ModelName=model_name, ExecutionRoleArn=role, PrimaryContainer=xgboost_hosting_container)
指定部署模型的配置：
from time import gmtime, strftime endpoint_config_name = 'XGBoostEndpointConfig-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) print(endpoint_config_name) create_endpoint_config_response = sm.create_endpoint_config( EndpointConfigName = endpoint_config_name, ProductionVariants=[{ 'InstanceType':'ml.m4.xlarge', 'InitialInstanceCount':1, 'InitialVariantWeight':1, 'ModelName':model_name, 'VariantName':'AllTraffic'}]) print("Endpoint Config Arn: " + create_endpoint_config_response['EndpointConfigArn'])
部署模型到终端节点：
# create endpoint import time endpoint_name = 'XGBoostEndpoint-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) print(endpoint_name) create_endpoint_response = sm.create_endpoint( EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name) print(create_endpoint_response['EndpointArn']) resp = sm.describe_endpoint(EndpointName=endpoint_name) status = resp['EndpointStatus'] print("Status: " + status) while status=='Creating': time.sleep(60) resp = sm.describe_endpoint(EndpointName=endpoint_name) status = resp['EndpointStatus'] print("Status: " + status) print("Arn: " + resp['EndpointArn']) print("Status: " + status)
6.1.3. XGBoost模型验证
文件为csv格式，需要转为numpy 数组，然后发送到部署好的终端节点，并获取到模型的预测值：
import io import sys runtime= boto3.client('runtime.sagemaker') # Simple function to create a csv from our numpy array def np2csv(arr): csv = io.BytesIO() np.savetxt(csv, arr, delimiter=',', fmt='%g') return csv.getvalue().decode().rstrip() # Function to generate prediction through sample data def do_predict(data, endpoint_name, content_type): payload = np2csv(data) response = runtime.invoke_endpoint(EndpointName=endpoint_name, ContentType=content_type, Body=payload) result = response['Body'].read() result = result.decode("utf-8") result = result.split(',') preds = [float((num)) for num in result] return preds # Function to iterate through a larger data set and generate batch predictions def batch_predict(data, batch_size, endpoint_name, content_type): items = len(data) arrs = [] for offset in range(0, items, batch_size): if offset+batch_size < items: datav = data.iloc[offset:(offset+batch_size),:].values results = do_predict(datav, endpoint_name, content_type) arrs.extend(results) else: datav = data.iloc[offset:items,:].values arrs.extend(do_predict(datav, endpoint_name, content_type)) sys.stdout.write('.') return(arrs)
获得训练数据、预测数据以及测试数据的预测值后，使用均方误差进行评估：
# do prediction preds_train_xgb = batch_predict(data_train.iloc[:, 1:], 1000, endpoint_name, 'text/csv') preds_val_xgb = batch_predict(data_val.iloc[:, 1:], 1000, endpoint_name, 'text/csv') preds_test_xgb = batch_predict(data_test, 1000, endpoint_name, 'text/csv') # evaluation from sklearn.metrics import mean_squared_error train_labels = data_train.iloc[:,0]; val_labels = data_val.iloc[:,0]; print("Training MSE", mean_squared_error(train_labels, preds_train_xgb)) print("Validation MSE", mean_squared_error(val_labels, preds_val_xgb)) print("Test MSE", mean_squared_error(test_target, preds_test_xgb)) Training MSE 0.10267861046608459 Validation MSE 0.27399804734388417 Test MSE 0.3310241908011309
从这个结果可以看出，模型稍微存在过拟合，在测试集上的误差要比测试集上的误差高0.23左右。
下面我们再训练第二个模型。
6.2. LinearLearner
在SageMaker中，LinearLearner模型训练的输入规则是：
- 输入格式支持recordIO-wrapped protobuf 和 CSV 格式
- 对于 text/csv 输入类型，第一列假定为标签，即预测的目标变量
前面我们已经处理好格式，下面直接指定参数并进行训练：
# train a linear model s3_output_location_linear = f's3://{bucket}/{prefix}/linear_output/' container = sagemaker.image_uris.retrieve("linear-learner", boto3.Session().region_name, version="1") linear_model = sagemaker.estimator.Estimator( container, role, input_mode="File", instance_count=1, instance_type="ml.m4.xlarge", output_path=s3_output_location_linear, sagemaker_session=sess, ) linear_model.set_hyperparameters( feature_dim=8, epochs=16, wd=0.01, loss="absolute_loss", predictor_type="regressor", normalize_data=False, optimizer="adam", mini_batch_size=100, lr_scheduler_step=100, lr_scheduler_factor=0.99, lr_scheduler_minimum_lr=0.0001, learning_rate=0.1, ) linear_model.fit({'train': train_channel, 'validation':val_channel})
训练结束后打印的指标为：
#validation_score (algo-1) : ('mse_objective', 0.31672970836480807)
#validation_score (algo-1) : ('mse', 0.31672970836480807)
可以看到在验证集上的均方误差为0.3167
6.2.1. LinearLearner 超参数调优
同样使用HyperparameterTuner 进行调优：
objective_metric_name = 'validation:objective_loss' hyperparameter_ranges = { 'learning_rate': ContinuousParameter(0.01, 0.1, scaling_type="Logarithmic"), 'l1': ContinuousParameter(0.01, 0.1, scaling_type="Logarithmic"), 'wd': ContinuousParameter(0.01, 0.1, scaling_type="Logarithmic") } tuner_linear_log = HyperparameterTuner( linear_model, objective_metric_name, hyperparameter_ranges, objective_type='Minimize', max_jobs=30, max_parallel_jobs=10, strategy='Random' ) tuner_linear_log.fit({'train': train_channel, 'validation': val_channel})
探索结果：
tuner_linear_log = sagemaker.HyperparameterTuningJobAnalytics(tuner_linear_log.latest_tuning_job.job_name).dataframe() tuner_linear_log['FinalObjectiveValue'].sort_values(ascending=True, inplace=False)[:3] 23 0.315122 17 0.316627 2 0.318820 Name: FinalObjectiveValue, dtype: float64 tuner_linear_log.loc[23] l1 0.013238 learning_rate 0.0322787 wd 0.010156 TrainingJobName linear-learner-210409-1752-007-7c0938e8 TrainingJobStatus Completed FinalObjectiveValue 0.315122 TrainingStartTime 2021-04-09 17:55:43+00:00 TrainingEndTime 2021-04-09 17:57:01+00:00 TrainingElapsedTimeSeconds 78 Name: 23, dtype: object
可以看到在这次超参数搜索中，排名最好的l1，learning_rate，wd参数组为：
l1 0.013238
learning_rate 0.0322787
wd 0.010156
对应的训练job为：linear-learner-210409-1752-007-7c0938e8
6.2.2 LinearLearner 模型部署
创建此训练job对应的模型：
# create model best_linear_model = tuner_linear_log.loc[tuner_linear_log['FinalObjectiveValue'].idxmin()]['TrainingJobName'] model_name=best_linear_model + '-lmdl' linear_hosting_container = { 'Image': container, 'ModelDataUrl': sm.describe_training_job(TrainingJobName=best_linear_model)['ModelArtifacts']['S3ModelArtifacts'] } create_model_response = sm.create_model( ModelName=model_name, ExecutionRoleArn=role, PrimaryContainer=linear_hosting_container)
指定部署模型的配置：
from time import gmtime, strftime endpoint_config_name = 'LinearEndpointConfig-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) print(endpoint_config_name) create_endpoint_config_response = sm.create_endpoint_config( EndpointConfigName = endpoint_config_name, ProductionVariants=[{ 'InstanceType':'ml.m4.xlarge', 'InitialInstanceCount':1, 'InitialVariantWeight':1, 'ModelName':model_name, 'VariantName':'AllTraffic'}]) print("Endpoint Config Arn: " + create_endpoint_config_response['EndpointConfigArn'])
部署模型到终端节点：
# create endpoint import time endpoint_name = 'LinearEndpoint-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) print(endpoint_name) create_endpoint_response = sm.create_endpoint( EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name) print(create_endpoint_response['EndpointArn']) resp = sm.describe_endpoint(EndpointName=endpoint_name) status = resp['EndpointStatus'] print("Status: " + status) while status=='Creating': time.sleep(60) resp = sm.describe_endpoint(EndpointName=endpoint_name) status = resp['EndpointStatus'] print("Status: " + status) print("Arn: " + resp['EndpointArn']) print("Status: " + status)
6.2.3. LinearLearnerr模型验证
import json def np2csv(arr): csv = io.BytesIO() np.savetxt(csv, arr, delimiter=',', fmt='%g') return csv.getvalue().decode().rstrip() # Function to generate prediction through sample data def do_predict_linear(data, endpoint_name, content_type): payload = np2csv(data) response = runtime.invoke_endpoint(EndpointName=endpoint_name, ContentType=content_type, Body=payload) result = json.loads(response['Body'].read().decode()) preds = [r['score'] for r in result['predictions']] return preds # Function to iterate through a larger data set and generate batch predictions def batch_predict_linear(data, batch_size, endpoint_name, content_type): items = len(data) arrs = [] for offset in range(0, items, batch_size): if offset+batch_size < items: datav = data.iloc[offset:(offset+batch_size),:].values results = do_predict_linear(datav, endpoint_name, content_type) arrs.extend(results) else: datav = data.iloc[offset:items,:].values arrs.extend(do_predict_linear(datav, endpoint_name, content_type)) sys.stdout.write('.') return(arrs) ### Predict preds_train_lin = batch_predict_linear(data_train.iloc[:,1:], 100, endpoint_name , 'text/csv') preds_val_lin = batch_predict_linear(data_val.iloc[:,1:], 100, endpoint_name , 'text/csv') preds_test_lin = batch_predict_linear(data_test, 100, endpoint_name , 'text/csv') print("Training MSE", mean_squared_error(train_labels, preds_train_lin)) print("Validation MSE", mean_squared_error(val_labels, preds_val_lin)) print("Test MSE", mean_squared_error(test_target, preds_test_lin)) Training MSE 0.3205520723200668 Validation MSE 0.3153403808426263 Test MSE 0.37555825359647615
可以看到LinearLearner的泛化性能较好，验证集和测试集上的表现没有出现太大偏差，但是准确度并不优秀。
6.3. 模型融合
最后将两个模型的结果取加权平均：
ens_train = 0.5*np.array(preds_train_xgb) + 0.5*np.array(preds_train_lin); ens_val = 0.5*np.array(preds_val_xgb) + 0.5*np.array(preds_val_lin); ens_test = 0.5*np.array(preds_test_xgb) + 0.5*np.array(preds_test_lin); print("Training MSE", mean_squared_error(train_labels, ens_train)) print("Validation MSE", mean_squared_error(val_labels, ens_val)) print("Test MSE", mean_squared_error(test_target, ens_test)) Training MSE 0.1786694748626782 Validation MSE 0.2740073446434298 Test MSE 0.3336424287800188
以上即为使用SageMaker进行模型训练、部署、以及验证的过程。对此结果来看，后续仍需要做部分优化。
从数据方面，还可以考虑：
- 做Box-Cox 变换，使数据更符合正态分布，使其更加符合后面数据挖掘方法对数据分布的假设
- 可以尝试不同的PCA参数
从模型训练方面，还可以考虑：
- 对xgboost增加l2 正则惩罚，缓解过拟合
- 对模型使用更多的参数搜索
- 尝试更优的lightGBM、SVM等算法
- 增加Bagging的模型数目
- 尝试Stacking