使用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='\t', encoding='utf-8')
test_raw = pd.read_csv(test_data_uri, sep='\t', 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