火力发电就是燃料燃烧加热水生成蒸汽&＃xff0c;蒸汽产生的压力推动汽轮机旋转&＃xff0c;进而带动电机旋转&＃xff0c;产生电能。其中一系列的能量转化中&＃xff0c;影响发电效率的核心是锅炉的燃烧效率&＃xff0c;即加热水产生的蒸汽量。而影响锅炉燃烧效率的因素很多&＃xff0c;包括锅炉床温、床压、炉膛温度、压力等等。
这个赛题的目标就是给一堆锅炉传感器采集的数据&＃xff08;38个特征变量&＃xff09;&＃xff0c;然后用训练好的模型预测出蒸汽量。因为预测值为连续型数值变量&＃xff0c;且给定的数据都带有标签&＃xff0c;故此问题是典型的回归预测问题。
典型的回归预测模型使用的算法包括&＃xff1a;线性回归&＃xff0c;岭回归&＃xff0c;LASSO回归&＃xff0c;决策树回归&＃xff0c;梯度提升树回归。
一个典型的机器学习实战算法基本包括 1) 数据处理&＃xff0c;2) 特征选取、优化&＃xff0c;和 3) 模型选取、验证、优化。 因为 “数据和特征决定了机器学习的上限&＃xff0c;而模型和算法知识逼近这个上限而已。” 所以在解决一个机器学习问题时大部分时间都会花在数据处理和特征优化上。
大家最好在jupyter notebook上一段一段地跑下面的代码&＃xff0c;加深理解。
机器学习的基本知识可以康康我的其他文章哦 好康的。
import warnings
warnings.filterwarnings("ignore")
import matplotlib.pyplot as plt
plt.rcParams.update({&＃039;figure.max_open_warning&＃039;: 0})
import seaborn as sns
# modelling
import pandas as pd
import numpy as np
from scipy import stats
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV, RepeatedKFold, cross_val_score,cross_val_predict,KFold
from sklearn.metrics import make_scorer,mean_squared_error
from sklearn.linear_model import LinearRegression, Lasso, Ridge, ElasticNet
from sklearn.svm import LinearSVR, SVR
from sklearn.neighbors import KNeighborsRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor,AdaBoostRegressor
from xgboost import XGBRegressor
from sklearn.preprocessing import PolynomialFeatures,MinMaxScaler,StandardScaler
#load_dataset
with open("./zhengqi_train.txt") as fr:
data_train&＃061;pd.read_table(fr,sep&＃061;"\t")
with open("./zhengqi_test.txt") as fr_test:
data_test&＃061;pd.read_table(fr_test,sep&＃061;"\t")
#merge train_set and test_set
data_train["oringin"]&＃061;"train"
data_test["oringin"]&＃061;"test"
data_all&＃061;pd.concat([data_train,data_test],axis&＃061;0,ignore_index&＃061;True)
data_all.drop(["V5","V9","V11","V17","V22","V28"],axis&＃061;1,inplace&＃061;True)
# normalise numeric columns
cols_numeric&＃061;list(data_all.columns)
cols_numeric.remove("oringin")
def scale_minmax(col):
return (col-col.min())/(col.max()-col.min())
scale_cols &＃061; [col for col in cols_numeric if col!&＃061;&＃039;target&＃039;]
data_all[scale_cols] &＃061; data_all[scale_cols].apply(scale_minmax,axis&＃061;0)
#Check effect of Box-Cox transforms on distributions of continuous variables
fcols &＃061; 6
frows &＃061; len(cols_numeric)-1
plt.figure(figsize&＃061;(4*fcols,4*frows))
i&＃061;0
for var in cols_numeric:
if var!&＃061;&＃039;target&＃039;:
dat &＃061; data_all[[var, &＃039;target&＃039;]].dropna()
i&＃043;&＃061;1
plt.subplot(frows,fcols,i)
sns.distplot(dat[var] , fit&＃061;stats.norm);
plt.title(var&＃043;&＃039; Original&＃039;)
plt.xlabel(&＃039;&＃039;)
i&＃043;&＃061;1
plt.subplot(frows,fcols,i)
_&＃061;stats.probplot(dat[var], plot&＃061;plt)
plt.title(&＃039;skew&＃061;&＃039;&＃043;&＃039;{:.4f}&＃039;.format(stats.skew(dat[var])))
plt.xlabel(&＃039;&＃039;)
plt.ylabel(&＃039;&＃039;)
i&＃043;&＃061;1
plt.subplot(frows,fcols,i)
plt.plot(dat[var], dat[&＃039;target&＃039;],&＃039;.&＃039;,alpha&＃061;0.5)
plt.title(&＃039;corr&＃061;&＃039;&＃043;&＃039;{:.2f}&＃039;.format(np.corrcoef(dat[var], dat[&＃039;target&＃039;])[0][1]))
i&＃043;&＃061;1
plt.subplot(frows,fcols,i)
trans_var, lambda_var &＃061; stats.boxcox(dat[var].dropna()&＃043;1)
trans_var &＃061; scale_minmax(trans_var)
sns.distplot(trans_var , fit&＃061;stats.norm);
plt.title(var&＃043;&＃039; Tramsformed&＃039;)
plt.xlabel(&＃039;&＃039;)
i&＃043;&＃061;1
plt.subplot(frows,fcols,i)
_&＃061;stats.probplot(trans_var, plot&＃061;plt)
plt.title(&＃039;skew&＃061;&＃039;&＃043;&＃039;{:.4f}&＃039;.format(stats.skew(trans_var)))
plt.xlabel(&＃039;&＃039;)
plt.ylabel(&＃039;&＃039;)
i&＃043;&＃061;1
plt.subplot(frows,fcols,i)
plt.plot(trans_var, dat[&＃039;target&＃039;],&＃039;.&＃039;,alpha&＃061;0.5)
plt.title(&＃039;corr&＃061;&＃039;&＃043;&＃039;{:.2f}&＃039;.format(np.corrcoef(trans_var,dat[&＃039;target&＃039;])[0][1]))
Box-Cox变换是Box和Cox在1964年提出的一种广义幂变换方法&＃xff0c;是统计建模中常用的一种数据变换&＃xff0c;用于连续的响应变量不满足正态分布的情况。Box-Cox变换之后&＃xff0c;可以一定程度上减小不可观测的误差和预测变量的相关性。Box-Cox变换的主要特点是引入一个参数&＃xff0c;通过数据本身估计该参数进而确定应采取的数据变换形式&＃xff0c;Box-Cox变换可以明显地改善数据的正态性、对称性和方差相等性&＃xff0c;对许多实际数据都是行之有效的。
cols_transform&＃061;data_all.columns[0:-2]
for col in cols_transform:
# transform column
data_all.loc[:,col], _ &＃061; stats.boxcox(data_all.loc[:,col]&＃043;1)
print(data_all.target.describe())
plt.figure(figsize&＃061;(12,4))
plt.subplot(1,2,1)
sns.distplot(data_all.target.dropna() , fit&＃061;stats.norm);
plt.subplot(1,2,2)
_&＃061;stats.probplot(data_all.target.dropna(), plot&＃061;plt)
#Log Transform SalePrice to improve normality
sp &＃061; data_train.target
data_train.target1 &＃061;np.power(1.5,sp)
print(data_train.target1.describe())
plt.figure(figsize&＃061;(12,4))
plt.subplot(1,2,1)
sns.distplot(data_train.target1.dropna(),fit&＃061;stats.norm);
plt.subplot(1,2,2)
_&＃061;stats.probplot(data_train.target1.dropna(), plot&＃061;plt)
# function to get training samples
def get_training_data():
# extract training samples
from sklearn.model_selection import train_test_split
df_train &＃061; data_all[data_all["oringin"]&＃061;&＃061;"train"]
df_train["label"]&＃061;data_train.target1
# split SalePrice and features
y &＃061; df_train.target
X &＃061; df_train.drop(["oringin","target","label"],axis&＃061;1)
X_train,X_valid,y_train,y_valid&＃061;train_test_split(X,y,test_size&＃061;0.3,random_state&＃061;100)
return X_train,X_valid,y_train,y_valid
# extract test data (without SalePrice)
def get_test_data():
df_test &＃061; data_all[data_all["oringin"]&＃061;&＃061;"test"].reset_index(drop&＃061;True)
return df_test.drop(["oringin","target"],axis&＃061;1)
from sklearn.metrics import make_scorer
# metric for evaluation
def rmse(y_true, y_pred):
diff &＃061; y_pred - y_true
sum_sq &＃061; sum(diff**2)
n &＃061; len(y_pred)
return np.sqrt(sum_sq/n)
def mse(y_ture,y_pred):
return mean_squared_error(y_ture,y_pred)
# scorer to be used in sklearn model fitting
rmse_scorer &＃061; make_scorer(rmse, greater_is_better&＃061;False)
mse_scorer &＃061; make_scorer(mse, greater_is_better&＃061;False)
# function to detect outliers based on the predictions of a model
def find_outliers(model, X, y, sigma&＃061;3):
# predict y values using model
try:
y_pred &＃061; pd.Series(model.predict(X), index&＃061;y.index)
# if predicting fails, try fitting the model first
except:
model.fit(X,y)
y_pred &＃061; pd.Series(model.predict(X), index&＃061;y.index)
# calculate residuals between the model prediction and true y values
resid &＃061; y - y_pred
mean_resid &＃061; resid.mean()
std_resid &＃061; resid.std()
# calculate z statistic, define outliers to be where |z|>sigma
z &＃061; (resid - mean_resid)/std_resid
outliers &＃061; z[abs(z)>sigma].index
# print and plot the results
print(&＃039;R2&＃061;&＃039;,model.score(X,y))
print(&＃039;rmse&＃061;&＃039;,rmse(y, y_pred))
print("mse&＃061;",mean_squared_error(y,y_pred))
print(&＃039;---------------------------------------&＃039;)
print(&＃039;mean of residuals:&＃039;,mean_resid)
print(&＃039;std of residuals:&＃039;,std_resid)
print(&＃039;---------------------------------------&＃039;)
print(len(outliers),&＃039;outliers:&＃039;)
print(outliers.tolist())
plt.figure(figsize&＃061;(15,5))
ax_131 &＃061; plt.subplot(1,3,1)
plt.plot(y,y_pred,&＃039;.&＃039;)
plt.plot(y.loc[outliers],y_pred.loc[outliers],&＃039;ro&＃039;)
plt.legend([&＃039;Accepted&＃039;,&＃039;Outlier&＃039;])
plt.xlabel(&＃039;y&＃039;)
plt.ylabel(&＃039;y_pred&＃039;);
ax_132&＃061;plt.subplot(1,3,2)
plt.plot(y,y-y_pred,&＃039;.&＃039;)
plt.plot(y.loc[outliers],y.loc[outliers]-y_pred.loc[outliers],&＃039;ro&＃039;)
plt.legend([&＃039;Accepted&＃039;,&＃039;Outlier&＃039;])
plt.xlabel(&＃039;y&＃039;)
plt.ylabel(&＃039;y - y_pred&＃039;);
ax_133&＃061;plt.subplot(1,3,3)
z.plot.hist(bins&＃061;50,ax&＃061;ax_133)
z.loc[outliers].plot.hist(color&＃061;&＃039;r&＃039;,bins&＃061;50,ax&＃061;ax_133)
plt.legend([&＃039;Accepted&＃039;,&＃039;Outlier&＃039;])
plt.xlabel(&＃039;z&＃039;)
plt.savefig(&＃039;outliers.png&＃039;)
return outliers
# get training data
from sklearn.linear_model import Ridge
X_train, X_valid,y_train,y_valid &＃061; get_training_data()
test&＃061;get_test_data()
# find and remove outliers using a Ridge model
outliers &＃061; find_outliers(Ridge(), X_train, y_train)
# permanently remove these outliers from the data
#df_train &＃061; data_all[data_all["oringin"]&＃061;&＃061;"train"]
#df_train["label"]&＃061;data_train.target1
#df_train&＃061;df_train.drop(outliers)
X_outliers&＃061;X_train.loc[outliers]
y_outliers&＃061;y_train.loc[outliers]
X_t&＃061;X_train.drop(outliers)
y_t&＃061;y_train.drop(outliers)
def get_trainning_data_omitoutliers():
y1&＃061;y_t.copy()
X1&＃061;X_t.copy()
return X1,y1
from sklearn.preprocessing import StandardScaler
def train_model(model, param_grid&＃061;[], X&＃061;[], y&＃061;[],
splits&＃061;5, repeats&＃061;5):
# get unmodified training data, unless data to use already specified
if len(y)&＃061;&＃061;0:
X,y &＃061; get_trainning_data_omitoutliers()
#poly_trans&＃061;PolynomialFeatures(degree&＃061;2)
#X&＃061;poly_trans.fit_transform(X)
#X&＃061;MinMaxScaler().fit_transform(X)
# create cross-validation method
rkfold &＃061; RepeatedKFold(n_splits&＃061;splits, n_repeats&＃061;repeats)
# perform a grid search if param_grid given
if len(param_grid)>0:
# setup grid search parameters
gsearch &＃061; GridSearchCV(model, param_grid, cv&＃061;rkfold,
scoring&＃061;"neg_mean_squared_error",
verbose&＃061;1, return_train_score&＃061;True)
# search the grid
gsearch.fit(X,y)
# extract best model from the grid
model &＃061; gsearch.best_estimator_
best_idx &＃061; gsearch.best_index_
# get cv-scores for best model
grid_results &＃061; pd.DataFrame(gsearch.cv_results_)
cv_mean &＃061; abs(grid_results.loc[best_idx,&＃039;mean_test_score&＃039;])
cv_std &＃061; grid_results.loc[best_idx,&＃039;std_test_score&＃039;]
# no grid search, just cross-val score for given model
else:
grid_results &＃061; []
cv_results &＃061; cross_val_score(model, X, y, scoring&＃061;"neg_mean_squared_error", cv&＃061;rkfold)
cv_mean &＃061; abs(np.mean(cv_results))
cv_std &＃061; np.std(cv_results)
# combine mean and std cv-score in to a pandas series
cv_score &＃061; pd.Series({&＃039;mean&＃039;:cv_mean,&＃039;std&＃039;:cv_std})
# predict y using the fitted model
y_pred &＃061; model.predict(X)
# print stats on model performance
print(&＃039;----------------------&＃039;)
print(model)
print(&＃039;----------------------&＃039;)
print(&＃039;score&＃061;&＃039;,model.score(X,y))
print(&＃039;rmse&＃061;&＃039;,rmse(y, y_pred))
print(&＃039;mse&＃061;&＃039;,mse(y, y_pred))
print(&＃039;cross_val: mean&＃061;&＃039;,cv_mean,&＃039;, std&＃061;&＃039;,cv_std)
# residual plots
y_pred &＃061; pd.Series(y_pred,index&＃061;y.index)
resid &＃061; y - y_pred
mean_resid &＃061; resid.mean()
std_resid &＃061; resid.std()
z &＃061; (resid - mean_resid)/std_resid
n_outliers &＃061; sum(abs(z)>3)
plt.figure(figsize&＃061;(15,5))
ax_131 &＃061; plt.subplot(1,3,1)
plt.plot(y,y_pred,&＃039;.&＃039;)
plt.xlabel(&＃039;y&＃039;)
plt.ylabel(&＃039;y_pred&＃039;);
plt.title(&＃039;corr &＃061; {:.3f}&＃039;.format(np.corrcoef(y,y_pred)[0][1]))
ax_132&＃061;plt.subplot(1,3,2)
plt.plot(y,y-y_pred,&＃039;.&＃039;)
plt.xlabel(&＃039;y&＃039;)
plt.ylabel(&＃039;y - y_pred&＃039;);
plt.title(&＃039;std resid &＃061; {:.3f}&＃039;.format(std_resid))
ax_133&＃061;plt.subplot(1,3,3)
z.plot.hist(bins&＃061;50,ax&＃061;ax_133)
plt.xlabel(&＃039;z&＃039;)
plt.title(&＃039;{:.0f} samples with z>3&＃039;.format(n_outliers))
return model, cv_score, grid_results
# places to store optimal models and scores
opt_models &＃061; dict()
score_models &＃061; pd.DataFrame(columns&＃061;[&＃039;mean&＃039;,&＃039;std&＃039;])
# no. k-fold splits
splits&＃061;5
# no. k-fold iterations
repeats&＃061;5
model &＃061; &＃039;Ridge&＃039;
opt_models[model] &＃061; Ridge()
alph_range &＃061; np.arange(0.25,6,0.25)
param_grid &＃061; {&＃039;alpha&＃039;: alph_range}
opt_models[model],cv_score,grid_results &＃061; train_model(opt_models[model], param_grid&＃061;param_grid,
splits&＃061;splits, repeats&＃061;repeats)
cv_score.name &＃061; model
score_models &＃061; score_models.append(cv_score)
plt.figure()
plt.errorbar(alph_range, abs(grid_results[&＃039;mean_test_score&＃039;]),
abs(grid_results[&＃039;std_test_score&＃039;])/np.sqrt(splits*repeats))
plt.xlabel(&＃039;alpha&＃039;)
plt.ylabel(&＃039;score&＃039;)
model &＃061; &＃039;Lasso&＃039;
opt_models[model] &＃061; Lasso()
alph_range &＃061; np.arange(1e-4,1e-3,4e-5)
param_grid &＃061; {&＃039;alpha&＃039;: alph_range}
opt_models[model], cv_score, grid_results &＃061; train_model(opt_models[model], param_grid&＃061;param_grid,
splits&＃061;splits, repeats&＃061;repeats)
cv_score.name &＃061; model
score_models &＃061; score_models.append(cv_score)
plt.figure()
plt.errorbar(alph_range, abs(grid_results[&＃039;mean_test_score&＃039;]),abs(grid_results[&＃039;std_test_score&＃039;])/np.sqrt(splits*repeats))
plt.xlabel(&＃039;alpha&＃039;)
plt.ylabel(&＃039;score&＃039;)
model &＃061;&＃039;ElasticNet&＃039;
opt_models[model] &＃061; ElasticNet()
param_grid &＃061; {&＃039;alpha&＃039;: np.arange(1e-4,1e-3,1e-4),
&＃039;l1_ratio&＃039;: np.arange(0.1,1.0,0.1),
&＃039;max_iter&＃039;:[100000]}
opt_models[model], cv_score, grid_results &＃061; train_model(opt_models[model], param_grid&＃061;param_grid,
splits&＃061;splits, repeats&＃061;1)
cv_score.name &＃061; model
score_models &＃061; score_models.append(cv_score)
model&＃061;&＃039;LinearSVR&＃039;
opt_models[model] &＃061; LinearSVR()
crange &＃061; np.arange(0.1,1.0,0.1)
param_grid &＃061; {&＃039;C&＃039;:crange,
&＃039;max_iter&＃039;:[1000]}
opt_models[model], cv_score, grid_results &＃061; train_model(opt_models[model], param_grid&＃061;param_grid,
splits&＃061;splits, repeats&＃061;repeats)
cv_score.name &＃061; model
score_models &＃061; score_models.append(cv_score)
plt.figure()
plt.errorbar(crange, abs(grid_results[&＃039;mean_test_score&＃039;]),abs(grid_results[&＃039;std_test_score&＃039;])/np.sqrt(splits*repeats))
plt.xlabel(&＃039;C&＃039;)
plt.ylabel(&＃039;score&＃039;)
model &＃061; &＃039;KNeighbors&＃039;
opt_models[model] &＃061; KNeighborsRegressor()
param_grid &＃061; {&＃039;n_neighbors&＃039;:np.arange(3,11,1)}
opt_models[model], cv_score, grid_results &＃061; train_model(opt_models[model], param_grid&＃061;param_grid,
splits&＃061;splits, repeats&＃061;1)
cv_score.name &＃061; model
score_models &＃061; score_models.append(cv_score)
plt.figure()
plt.errorbar(np.arange(3,11,1), abs(grid_results[&＃039;mean_test_score&＃039;]),abs(grid_results[&＃039;std_test_score&＃039;])/np.sqrt(splits*1))
plt.xlabel(&＃039;n_neighbors&＃039;)
plt.ylabel(&＃039;score&＃039;)
model &＃061; &＃039;GradientBoosting&＃039;
opt_models[model] &＃061; GradientBoostingRegressor()
param_grid &＃061; {&＃039;n_estimators&＃039;:[150,250,350],
&＃039;max_depth&＃039;:[1,2,3],
&＃039;min_samples_split&＃039;:[5,6,7]}
opt_models[model], cv_score, grid_results &＃061; train_model(opt_models[model], param_grid&＃061;param_grid,
splits&＃061;splits, repeats&＃061;1)
cv_score.name &＃061; model
score_models &＃061; score_models.append(cv_score)
model &＃061; &＃039;XGB&＃039;
opt_models[model] &＃061; XGBRegressor()
param_grid &＃061; {&＃039;n_estimators&＃039;:[100,200,300,400,500],
&＃039;max_depth&＃039;:[1,2,3],
}
opt_models[model], cv_score,grid_results &＃061; train_model(opt_models[model], param_grid&＃061;param_grid,
splits&＃061;splits, repeats&＃061;1)
cv_score.name &＃061; model
score_models &＃061; score_models.append(cv_score)
model &＃061; &＃039;RandomForest&＃039;
opt_models[model] &＃061; RandomForestRegressor()
param_grid &＃061; {&＃039;n_estimators&＃039;:[100,150,200],
&＃039;max_features&＃039;:[8,12,16,20,24],
&＃039;min_samples_split&＃039;:[2,4,6]}
opt_models[model], cv_score, grid_results &＃061; train_model(opt_models[model], param_grid&＃061;param_grid,
splits&＃061;5, repeats&＃061;1)
cv_score.name &＃061; model
score_models &＃061; score_models.append(cv_score)
def model_predict(test_data,test_y&＃061;[],stack&＃061;False):
#poly_trans&＃061;PolynomialFeatures(degree&＃061;2)
#test_data1&＃061;poly_trans.fit_transform(test_data)
#test_data&＃061;MinMaxScaler().fit_transform(test_data)
i&＃061;0
y_predict_total&＃061;np.zeros((test_data.shape[0],))
for model in opt_models.keys():
if model!&＃061;"LinearSVR" and model!&＃061;"KNeighbors":
y_predict&＃061;opt_models[model].predict(test_data)
y_predict_total&＃043;&＃061;y_predict
i&＃043;&＃061;1
if len(test_y)>0:
print("{}_mse:".format(model),mean_squared_error(y_predict,test_y))
y_predict_mean&＃061;np.round(y_predict_total/i,3)
if len(test_y)>0:
print("mean_mse:",mean_squared_error(y_predict_mean,test_y))
else:
y_predict_mean&＃061;pd.Series(y_predict_mean)
return y_predict_mean
model_predict(X_valid,y_valid)
模型融合&＃xff0c;即先产生一组个体模型&＃xff0c;再用某种策略将它们结合起来&＃xff0c;以加强模型效果。
分析表明&＃xff0c;随着集成中个体模型数量T增加&＃xff0c;集成模型的错误率将呈指数级下降&＃xff0c;最终趋于0。通过融合可以达到取长补短的效果&＃xff0c;综合个体模型的优势能降低预测误差、优化整体模型的性能。而且个体模型的准确率越高&＃xff0c;多样性越大&＃xff0c;模型融合的提升效果就越好&＃xff01;
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import itertools
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
##主要使用pip install mlxtend安装mlxtend
from mlxtend.classifier import EnsembleVoteClassifier
from mlxtend.data import iris_data
from mlxtend.plotting import plot_decision_regions
%matplotlib inline
# Initializing Classifiers
clf1 &＃061; LogisticRegression(random_state&＃061;0)
clf2 &＃061; RandomForestClassifier(random_state&＃061;0)
clf3 &＃061; SVC(random_state&＃061;0, probability&＃061;True)
eclf &＃061; EnsembleVoteClassifier(clfs&＃061;[clf1, clf2, clf3], weights&＃061;[2, 1, 1], voting&＃061;&＃039;soft&＃039;)
# Loading some example data
X, y &＃061; iris_data()
X &＃061; X[:,[0, 2]]
# Plotting Decision Regions
gs &＃061; gridspec.GridSpec(2, 2)
fig &＃061; plt.figure(figsize&＃061;(10, 8))
for clf, lab, grd in zip([clf1, clf2, clf3, eclf],
[&＃039;Logistic Regression&＃039;, &＃039;Random Forest&＃039;, &＃039;RBF kernel SVM&＃039;, &＃039;Ensemble&＃039;],
itertools.product([0, 1], repeat&＃061;2)):
clf.fit(X, y)
ax &＃061; plt.subplot(gs[grd[0], grd[1]])
fig &＃061; plot_decision_regions(X&＃061;X, y&＃061;y, clf&＃061;clf, legend&＃061;2)
plt.title(lab)
plt.show()
from sklearn.model_selection import train_test_split
import pandas as pd
import numpy as np
from scipy import sparse
import xgboost
import lightgbm
from sklearn.ensemble import RandomForestRegressor,AdaBoostRegressor,GradientBoostingRegressor,ExtraTreesRegressor
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
def stacking_reg(clf,train_x,train_y,test_x,clf_name,kf,label_split&＃061;None):
train&＃061;np.zeros((train_x.shape[0],1))
test&＃061;np.zeros((test_x.shape[0],1))
test_pre&＃061;np.empty((folds,test_x.shape[0],1))
cv_scores&＃061;[]
for i,(train_index,test_index) in enumerate(kf.split(train_x,label_split)):
tr_x&＃061;train_x[train_index]
tr_y&＃061;train_y[train_index]
te_x&＃061;train_x[test_index]
te_y &＃061; train_y[test_index]
if clf_name in ["rf","ada","gb","et","lr","lsvc","knn"]:
clf.fit(tr_x,tr_y)
pre&＃061;clf.predict(te_x).reshape(-1,1)
train[test_index]&＃061;pre
test_pre[i,:]&＃061;clf.predict(test_x).reshape(-1,1)
cv_scores.append(mean_squared_error(te_y, pre))
elif clf_name in ["xgb"]:
train_matrix &＃061; clf.DMatrix(tr_x, label&＃061;tr_y, missing&＃061;-1)
test_matrix &＃061; clf.DMatrix(te_x, label&＃061;te_y, missing&＃061;-1)
z &＃061; clf.DMatrix(test_x, label&＃061;te_y, missing&＃061;-1)
params &＃061; {&＃039;booster&＃039;: &＃039;gbtree&＃039;,
&＃039;eval_metric&＃039;: &＃039;rmse&＃039;,
&＃039;gamma&＃039;: 1,
&＃039;min_child_weight&＃039;: 1.5,
&＃039;max_depth&＃039;: 5,
&＃039;lambda&＃039;: 10,
&＃039;subsample&＃039;: 0.7,
&＃039;colsample_bytree&＃039;: 0.7,
&＃039;colsample_bylevel&＃039;: 0.7,
&＃039;eta&＃039;: 0.03,
&＃039;tree_method&＃039;: &＃039;exact&＃039;,
&＃039;seed&＃039;: 2017,
&＃039;nthread&＃039;: 12
}
num_round &＃061; 10000
early_stopping_rounds &＃061; 100
watchlist &＃061; [(train_matrix, &＃039;train&＃039;),
(test_matrix, &＃039;eval&＃039;)
]
if test_matrix:
model &＃061; clf.train(params, train_matrix, num_boost_round&＃061;num_round,evals&＃061;watchlist,
early_stopping_rounds&＃061;early_stopping_rounds
)
pre&＃061; model.predict(test_matrix,ntree_limit&＃061;model.best_ntree_limit).reshape(-1,1)
train[test_index]&＃061;pre
test_pre[i, :]&＃061; model.predict(z, ntree_limit&＃061;model.best_ntree_limit).reshape(-1,1)
cv_scores.append(mean_squared_error(te_y, pre))
elif clf_name in ["lgb"]:
train_matrix &＃061; clf.Dataset(tr_x, label&＃061;tr_y)
test_matrix &＃061; clf.Dataset(te_x, label&＃061;te_y)
#z &＃061; clf.Dataset(test_x, label&＃061;te_y)
#z&＃061;test_x
params &＃061; {
&＃039;boosting_type&＃039;: &＃039;gbdt&＃039;,
&＃039;objective&＃039;: &＃039;regression_l2&＃039;,
&＃039;metric&＃039;: &＃039;mse&＃039;,
&＃039;min_child_weight&＃039;: 1.5,
&＃039;num_leaves&＃039;: 2**5,
&＃039;lambda_l2&＃039;: 10,
&＃039;subsample&＃039;: 0.7,
&＃039;colsample_bytree&＃039;: 0.7,
&＃039;colsample_bylevel&＃039;: 0.7,
&＃039;learning_rate&＃039;: 0.03,
&＃039;tree_method&＃039;: &＃039;exact&＃039;,
&＃039;seed&＃039;: 2017,
&＃039;nthread&＃039;: 12,
&＃039;silent&＃039;: True,
}
num_round &＃061; 10000
early_stopping_rounds &＃061; 100
if test_matrix:
model &＃061; clf.train(params, train_matrix,num_round,valid_sets&＃061;test_matrix,
early_stopping_rounds&＃061;early_stopping_rounds
)
pre&＃061; model.predict(te_x,num_iteration&＃061;model.best_iteration).reshape(-1,1)
train[test_index]&＃061;pre
test_pre[i, :]&＃061; model.predict(test_x, num_iteration&＃061;model.best_iteration).reshape(-1,1)
cv_scores.append(mean_squared_error(te_y, pre))
else:
raise IOError("Please add new clf.")
print("%s now score is:"%clf_name,cv_scores)
test[:]&＃061;test_pre.mean(axis&＃061;0)
print("%s_score_list:"%clf_name,cv_scores)
print("%s_score_mean:"%clf_name,np.mean(cv_scores))
return train.reshape(-1,1),test.reshape(-1,1)
def rf_reg(x_train, y_train, x_valid, kf, label_split&＃061;None):
randomforest &＃061; RandomForestRegressor(n_estimators&＃061;600, max_depth&＃061;20, n_jobs&＃061;-1, random_state&＃061;2017, max_features&＃061;"auto",verbose&＃061;1)
rf_train, rf_test &＃061; stacking_reg(randomforest, x_train, y_train, x_valid, "rf", kf, label_split&＃061;label_split)
return rf_train, rf_test,"rf_reg"
def ada_reg(x_train, y_train, x_valid, kf, label_split&＃061;None):
adaboost &＃061; AdaBoostRegressor(n_estimators&＃061;30, random_state&＃061;2017, learning_rate&＃061;0.01)
ada_train, ada_test &＃061; stacking_reg(adaboost, x_train, y_train, x_valid, "ada", kf, label_split&＃061;label_split)
return ada_train, ada_test,"ada_reg"
def gb_reg(x_train, y_train, x_valid, kf, label_split&＃061;None):
gbdt &＃061; GradientBoostingRegressor(learning_rate&＃061;0.04, n_estimators&＃061;100, subsample&＃061;0.8, random_state&＃061;2017,max_depth&＃061;5,verbose&＃061;1)
gbdt_train, gbdt_test &＃061; stacking_reg(gbdt, x_train, y_train, x_valid, "gb", kf, label_split&＃061;label_split)
return gbdt_train, gbdt_test,"gb_reg"
def et_reg(x_train, y_train, x_valid, kf, label_split&＃061;None):
extratree &＃061; ExtraTreesRegressor(n_estimators&＃061;600, max_depth&＃061;35, max_features&＃061;"auto", n_jobs&＃061;-1, random_state&＃061;2017,verbose&＃061;1)
et_train, et_test &＃061; stacking_reg(extratree, x_train, y_train, x_valid, "et", kf, label_split&＃061;label_split)
return et_train, et_test,"et_reg"
def lr_reg(x_train, y_train, x_valid, kf, label_split&＃061;None):
lr_reg&＃061;LinearRegression(n_jobs&＃061;-1)
lr_train, lr_test &＃061; stacking_reg(lr_reg, x_train, y_train, x_valid, "lr", kf, label_split&＃061;label_split)
return lr_train, lr_test, "lr_reg"
def xgb_reg(x_train, y_train, x_valid, kf, label_split&＃061;None):
xgb_train, xgb_test &＃061; stacking_reg(xgboost, x_train, y_train, x_valid, "xgb", kf, label_split&＃061;label_split)
return xgb_train, xgb_test,"xgb_reg"
def lgb_reg(x_train, y_train, x_valid, kf, label_split&＃061;None):
lgb_train, lgb_test &＃061; stacking_reg(lightgbm, x_train, y_train, x_valid, "lgb", kf, label_split&＃061;label_split)
return lgb_train, lgb_test,"lgb_reg"
def stacking_pred(x_train, y_train, x_valid, kf, clf_list, label_split&＃061;None, clf_fin&＃061;"lgb", if_concat_origin&＃061;True):
for k, clf_list in enumerate(clf_list):
clf_list &＃061; [clf_list]
column_list &＃061; []
train_data_list&＃061;[]
test_data_list&＃061;[]
for clf in clf_list:
train_data,test_data,clf_name&＃061;clf(x_train, y_train, x_valid, kf, label_split&＃061;label_split)
train_data_list.append(train_data)
test_data_list.append(test_data)
column_list.append("clf_%s" % (clf_name))
train &＃061; np.concatenate(train_data_list, axis&＃061;1)
test &＃061; np.concatenate(test_data_list, axis&＃061;1)
if if_concat_origin:
train &＃061; np.concatenate([x_train, train], axis&＃061;1)
test &＃061; np.concatenate([x_valid, test], axis&＃061;1)
print(x_train.shape)
print(train.shape)
print(clf_name)
print(clf_name in ["lgb"])
if clf_fin in ["rf","ada","gb","et","lr","lsvc","knn"]:
if clf_fin in ["rf"]:
clf &＃061; RandomForestRegressor(n_estimators&＃061;600, max_depth&＃061;20, n_jobs&＃061;-1, random_state&＃061;2017, max_features&＃061;"auto",verbose&＃061;1)
elif clf_fin in ["ada"]:
clf &＃061; AdaBoostRegressor(n_estimators&＃061;30, random_state&＃061;2017, learning_rate&＃061;0.01)
elif clf_fin in ["gb"]:
clf &＃061; GradientBoostingRegressor(learning_rate&＃061;0.04, n_estimators&＃061;100, subsample&＃061;0.8, random_state&＃061;2017,max_depth&＃061;5,verbose&＃061;1)
elif clf_fin in ["et"]:
clf &＃061; ExtraTreesRegressor(n_estimators&＃061;600, max_depth&＃061;35, max_features&＃061;"auto", n_jobs&＃061;-1, random_state&＃061;2017,verbose&＃061;1)
elif clf_fin in ["lr"]:
clf &＃061; LinearRegression(n_jobs&＃061;-1)
clf.fit(train, y_train)
pre &＃061; clf.predict(test).reshape(-1,1)
return pred
elif clf_fin in ["xgb"]:
clf &＃061; xgboost
train_matrix &＃061; clf.DMatrix(train, label&＃061;y_train, missing&＃061;-1)
test_matrix &＃061; clf.DMatrix(train, label&＃061;y_train, missing&＃061;-1)
params &＃061; {&＃039;booster&＃039;: &＃039;gbtree&＃039;,
&＃039;eval_metric&＃039;: &＃039;rmse&＃039;,
&＃039;gamma&＃039;: 1,
&＃039;min_child_weight&＃039;: 1.5,
&＃039;max_depth&＃039;: 5,
&＃039;lambda&＃039;: 10,
&＃039;subsample&＃039;: 0.7,
&＃039;colsample_bytree&＃039;: 0.7,
&＃039;colsample_bylevel&＃039;: 0.7,
&＃039;eta&＃039;: 0.03,
&＃039;tree_method&＃039;: &＃039;exact&＃039;,
&＃039;seed&＃039;: 2017,
&＃039;nthread&＃039;: 12
}
num_round &＃061; 10000
early_stopping_rounds &＃061; 100
watchlist &＃061; [(train_matrix, &＃039;train&＃039;),
(test_matrix, &＃039;eval&＃039;)
]
model &＃061; clf.train(params, train_matrix, num_boost_round&＃061;num_round,evals&＃061;watchlist,
early_stopping_rounds&＃061;early_stopping_rounds
)
pre &＃061; model.predict(test,ntree_limit&＃061;model.best_ntree_limit).reshape(-1,1)
return pre
elif clf_fin in ["lgb"]:
print(clf_name)
clf &＃061; lightgbm
train_matrix &＃061; clf.Dataset(train, label&＃061;y_train)
test_matrix &＃061; clf.Dataset(train, label&＃061;y_train)
params &＃061; {
&＃039;boosting_type&＃039;: &＃039;gbdt&＃039;,
&＃039;objective&＃039;: &＃039;regression_l2&＃039;,
&＃039;metric&＃039;: &＃039;mse&＃039;,
&＃039;min_child_weight&＃039;: 1.5,
&＃039;num_leaves&＃039;: 2**5,
&＃039;lambda_l2&＃039;: 10,
&＃039;subsample&＃039;: 0.7,
&＃039;colsample_bytree&＃039;: 0.7,
&＃039;colsample_bylevel&＃039;: 0.7,
&＃039;learning_rate&＃039;: 0.03,
&＃039;tree_method&＃039;: &＃039;exact&＃039;,
&＃039;seed&＃039;: 2017,
&＃039;nthread&＃039;: 12,
&＃039;silent&＃039;: True,
}
num_round &＃061; 10000
early_stopping_rounds &＃061; 100
model &＃061; clf.train(params, train_matrix,num_round,valid_sets&＃061;test_matrix,
early_stopping_rounds&＃061;early_stopping_rounds
)
print(&＃039;pred&＃039;)
pre &＃061; model.predict(test,num_iteration&＃061;model.best_iteration).reshape(-1,1)
print(pre)
return pre
# #load_dataset
with open("./zhengqi_train.txt") as fr:
data_train&＃061;pd.read_table(fr,sep&＃061;"\t")
with open("./zhengqi_test.txt") as fr_test:
data_test&＃061;pd.read_table(fr_test,sep&＃061;"\t")
from sklearn.model_selection import StratifiedKFold, KFold
folds &＃061; 5
seed &＃061; 1
kf &＃061; KFold(n_splits&＃061;5, shuffle&＃061;True, random_state&＃061;0)
x_train &＃061; data_train[data_test.columns].values
x_valid &＃061; data_test[data_test.columns].values
y_train &＃061; data_train[&＃039;target&＃039;].values
clf_list &＃061; [lr_reg, lgb_reg]
#clf_list &＃061; [lr_reg, rf_reg]
##很容易过拟合
pred &＃061; stacking_pred(x_train, y_train, x_valid, kf, clf_list, label_split&＃061;None, clf_fin&＃061;"lgb", if_concat_origin&＃061;True)
以上内容和代码全部来自于《阿里云天池大赛赛题解析(机器学习篇)》这本好书&＃xff0c;十分推荐大家去阅读原书&＃xff01;
京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有 