• 回归模型原理总结及代码实现

    前言

    本文将介绍回归模型算法，并总结了一些常用的除线性回归模型之外的模型，其中包括一些单模型及集成学习器。

    保序回归、多项式回归、多输出回归、多输出K近邻回归、决策树回归、多输出决策树回归、AdaBoost回归、梯度提升决策树回归、人工神经网络、随机森林回归、多输出随机森林回归、XGBoost回归。

    需要面试或者需要总体了解/复习机器学习回归模型的小伙伴可以通读下本文，理论总结加代码实操，有助于理解模型。

    图片

    保序回归

    保序回归或单调回归是一种将自由形式的直线拟合到一系列观测值上的技术，这样拟合的直线在所有地方都是非递减(或非递增)的，并且尽可能靠近观测值。

    理论规则是

    • 如果预测输入与训练中的特征值完全匹配，则返回相应标签。如果一个特征值对应多个预测标签值，则返回其中一个，具体是哪一个未指定。

    • 如果预测输入比训练中的特征值都高（或者都低），则相应返回最高特征值或者最低特征值对应标签。如果一个特征值对应多个预测标签值，则相应返回最高值或者最低值。

    • 如果预测输入落入两个特征值之间，则预测将会是一个分段线性函数，其值由两个最近的特征值的预测值计算得到。如果一个特征值对应多个预测标签值，则使用上述两种情况中的处理方式解决。

    1. n = len(dataset['Adj Close'])
    2. X = np.array(dataset['Open'].values)
    3. y = dataset['Adj Close'].values
    4. from sklearn.isotonic import IsotonicRegression
    5.  
    6. ir=IsotonicRegression()
    7. y_ir=ir.fit_transform(X,y)

    将拟合过程可视化

    红色散点图是原始数据X-y关系图，绿色线为保序回归拟合后的数据X-y_ir关系图。这里以可视化的形式表现了保序回归的理论规则。

    1. lines=[[[i,y[i]],[i,y_ir[i]]] for i in range(n)]
    2. lc=LineCollection(lines)
    3. plt.figure(figsize=(15,6))
    4. plt.plot(X,y,'r.',markersize=12)
    5. plt.plot(X,y_ir,'g.-',markersize=12)
    6. plt.gca().add_collection(lc)
    7. plt.legend(('Data','Isotonic Fit','Linear Fit'))
    8. plt.title("Isotonic Regression")
    9. plt.show()

    图片

     

    多项式回归

    多项式回归(PolynomialFeatures)是一种用多项式函数作为自变量的非线性方程的回归方法。

    将数据转换为多项式。多项式回归是一般线性回归模型的特殊情况。它对于描述曲线关系很有用。曲线关系可以通过平方或设置预测变量的高阶项来实现。

    sklearn中的多项式拟合

    1. X = dataset.iloc[ : , 0:4].values
    2. Y = dataset.iloc[ : ,  4].values
    3.  
    4. from sklearn.preprocessing import PolynomialFeatures
    5. from sklearn.linear_model import LinearRegression
    6.  
    7. poly=PolynomialFeatures(degree=3)
    8. poly_x=poly.fit_transform(X)
    9.  
    10. regressor=LinearRegression()
    11. regressor.fit(poly_x,Y)
    12.  
    13. plt.scatter(X,Y,color='red')
    14. plt.plot(X,regressor.predict(poly.fit_transform(X)),color='blue')
    15. plt.show()

    以原始数据绘制X-Y红色散点图，并绘制蓝色的、经过多项式拟合后再进行线性回归模型拟合的直线图。

    图片

     一元自变量计算三阶多项式
    1. from scipy import *
    2. f = np.polyfit(X,Y,3)
    3. p = np.poly1d(f)
    4. print(p)
    多元自变量的多项式
    1. from sklearn.preprocessing import PolynomialFeatures
    2. from sklearn import linear_model
    3. X = np.array(dataset[['Open', 'High', 'Low']].values)
    4. Y = np.array(dataset['Adj Close'].values)
    5.  
    6. Y = Y.reshape(Y.shape[0], -1)
    7. poly = PolynomialFeatures(degree=3)
    8. X_ = poly.fit_transform(X)
    9. predict_ = poly.fit_transform(Y)
    Pipeline形式
    1. from sklearn.pipeline import Pipeline
    2. X = np.array(dataset['Open'].values)
    3. Y = np.array(dataset['Adj Close'].values)
    4. X = X.reshape(X.shape[0], -1)
    5. Y = Y.reshape(Y.shape[0], -1)
    6. Input=[('scale',StandardScaler()),('polynomial', PolynomialFeatures(include_bias=False)),('model',LinearRegression())]
    7. pipe = Pipeline(Input)
    8. pipe.fit(X,Y)
    9. yhat = pipe.predict(X)
    10. yhat[0:4]

    numpy 中的多项式拟合

    首先理解nump用于多项式拟合的两个主要方法。

    np.poly1d
    np.poly1d(c_or_r, r=False, variable=None)

    一维多项式类，用于封装多项式上的"自然"操作，以便上述操作可以在代码中采用惯用形式。如何理解呢？看看下面几个例子。

    • c_or_r系数向量
    1. import numpy as np
    2. a=np.array([2,1,1])
    3. f=np.poly1d(a)
    4. print(f)
    • r=False是否反推

    表示把数组中的值作为根，然后反推多项式。 

    1. f=np.poly1d([2,3,5],r=True)
    2. #(x - 2)*(x - 3)*(x - 5)  = x^3 - 10x^2 + 31x -30
    3. print(f)
    • variable=None表示改变未知数的字母
    1. f=np.poly1d([2,3,5],r=True,variable='z')
    2. print(f)
    np.polyfit
    np.polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False)
     最小二乘多项式拟合

    拟合多项式p(x)=p_0x+p_1x^{2}+\cdot \cdot \cdot +p_nx^{n}。返回一个系数'p'的向量，以最小化平方误差的顺序'deg'，'deg-1'，…"0"。

    推荐使用  类方法，因为它在数值上更稳定。

    下图是以原始数据绘制的蓝色X-Y散点图，以及红色的X分布图。

    1. X = dataset['Open'].values
    2. y = dataset['Adj Close'].values
    3. from sklearn.model_selection import train_test_split
    4. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
    5. plt.figure(figsize=(10,6))
    6. plt.plot(X_train, y_train, 'bo')
    7. plt.plot(X_test, np.zeros_like(X_test), 'r+')
    8. plt.show()

    图片

     numpy与sklearn中的多项式回归对比
    1. # numpy
    2. model_one = np.poly1d(np.polyfit(X_train, y_train,1))
    3. preds_one = model_one(X_test)
    4. print(preds_one[:3])
    5. >>> [11.59609048 10.16018804 25.23716889]
    6. # sklearn
    7. from sklearn.linear_model import LinearRegression
    8. model = LinearRegression()
    9. model.fit(X_train.reshape(-1, 1), y_train)
    10. preds = model.predict(X_test.reshape(-1, 1))
    11. preds[:3]
    12. >>> array([11.59609048, 10.16018804, 25.23716889])
    13. # 预测结果是一样的
    14. print("all close?", np.allclose(preds, preds_one))
    15. >>> 'all close? True

    结果表明两者相比预测结果时一致的。

    多阶多项式效果对比

    比较一阶、二阶及三阶多项式拟合，多线性回归模型的效果影响。由图可看出，三条线基本重合，且RMSE相差不大。

    1. model_one = np.poly1d(np.polyfit(X_train, y_train,1))
    2. model_two = np.poly1d(np.polyfit(X_train, y_train, 2))
    3. model_three = np.poly1d(np.polyfit(X_train, y_train, 3))
    4.  
    5. fig, axes = plt.subplots(1, 2, figsize=(14, 5),sharey=True)
    6. labels = ['line', 'parabola', 'nonic']
    7. models = [model_one, model_two, model_three]
    8. train = (X_train, y_train)
    9. test = (X_test, y_test)
    10. for ax, (ftr, tgt) in zip(axes, [train, test]):
    11.     ax.plot(ftr, tgt, 'k+')
    12.     num = 0
    13.     for m, lbl in zip(models, labels):
    14.         ftr = sorted(ftr)
    15.         ax.plot(ftr, m(ftr), '-', label=lbl)
    16.         if ax == axes[1]:
    17.             ax.text(2,55-num, f"{lbl}_RMSE: {round(np.sqrt(mse(tgt, m(tgt))),3)}")
    18.             num += 5
    19. axes[1].set_ylim(-10, 60)
    20. axes[0].set_title("Train")
    21. axes[1].set_title("Test");
    22. axes[0].legend(loc='best');

    图片

     绘制类似学习曲线

    因低阶多项式效果相差并不明显，因此增大多项式阶数，并以残差平方和为y轴，看模型拟合效果，由图可以看出，随着多项式阶数越来越高，模型出现严重的过拟合（训练集残差平方和降低，而测试集却在上涨）。

    1. results = []
    2. for complexity in [1, 2, 3, 4, 5, 6,7,8, 9]:
    3.     model = np.poly1d(np.polyfit(X_train, y_train, complexity))
    4.     train_error = np.sqrt(mse(y_train, model(X_train)))
    5.     test_error = np.sqrt(mse(y_test,model(X_test)))
    6.     results.append((complexity, train_error, test_error))
    7. columns = ["Complexity", "Train Error", "Test Error"]
    8. results_df = pd.DataFrame.from_records(results, 
    9.               columns=columns,
    10.               index="Complexity")
    11. results_df
    12. results_df.plot(figsize=(10,6))

    图片

     

     多输出回归

    多输出回归为每个样本分配一组目标值。这可以认为是预测每一个样本的多个属性，比如说一个具体地点的风的方向和大小。

    多输出回归支持 MultiOutputRegressor 可以被添加到任何回归器中。这个策略包括对每个目标拟合一个回归器。因为每一个目标可以被一个回归器精确地表示，通过检查对应的回归器，可以获取关于目标的信息。因为 MultiOutputRegressor 对于每一个目标可以训练出一个回归器，所以它无法利用目标之间的相关度信息。

    支持多类-多输出分类的分类器:

    1. sklearn.tree.DecisionTreeClassifier 
    2. sklearn.tree.ExtraTreeClassifier  
    3. sklearn.ensemble.ExtraTreesClassifier  
    4. sklearn.neighbors.KNeighborsClassifier
    5. sklearn.neighbors.RadiusNeighborsClassifier
    6. sklearn.ensemble.RandomForestClassifier
    7. X = dataset.drop(['Adj Close', 'Open'], axis=1)
    8. Y = dataset[['Adj Close', 'Open']]
    9.  
    10. from sklearn.multioutput import MultiOutputRegressor
    11. from sklearn.svm import LinearSVR
    12.  
    13. model = LinearSVR()
    14. wrapper = MultiOutputRegressor(model)
    15. wrapper.fit(X, Y)
    16.  
    17. data_in = [[23.98, 22.91, 7.00, 7.00, 
    18.             1.62, 1.62, 4.27, 4.25]]
    19. yhat = wrapper.predict(data_in)
    20. print(yhat[0])
    21. >>> [16.72625136 16.72625136]
    22. wrapper.score(X, Y)

    多输出K近邻回归

    多输出K近邻回归可以不使用MultiOutputRegressor作为外包装器，直接使用KNeighborsRegressor便可以实现多输出回归。

    1. X = dataset.drop(['Adj Close', 'Open'], axis=1)
    2. Y = dataset[['Adj Close', 'Open']]
    3. from sklearn.neighbors import KNeighborsRegressor
    4. model = KNeighborsRegressor()
    5. model.fit(X, Y)
    6. data_in = [[23.98, 22.91, 7.00, 7.00, 
    7.             1.62, 1.62, 4.27, 4.25]]
    8. yhat = model.predict(data_in)
    9. print(yhat[0])
    10. >>> [2.34400001 2.352     ]
    11. model.score(X, Y)
    12. >>> 0.7053689393640217

    决策树回归

    决策树是一种树状结构，她的每一个叶子结点对应着一个分类，非叶子结点对应着在某个属性上的划分，根据样本在该属性上的不同取值降气划分成若干个子集。

    基本原理

    数模型通过递归切割的方法来寻找最佳分类标准，进而最终形成规则。CATA树，对回归树用平方误差最小化准则，进行特征选择，生成二叉树。

    CATA回归树的生成

    在训练数据集所在的空间中，递归地将每个空间区域划分为两个子区域，并决定每个子区域上的输出值，生产二叉树。

    选择最优切分变量j和最优切分点s，求解

    遍历 j，对固定的切分变量 j 扫描切分点 s ，使得上式达到最小值的对 (j,s) ，不断循环直至满足条件停止。

    1. X = dataset.drop(['Adj Close', 'Close'], axis=1)  
    2. y = dataset['Adj Close'] 
    3. # 划分训练集和测试集略 
    4. # 模型实例化
    5. from sklearn.tree import DecisionTreeRegressor  
    6. regressor = DecisionTreeRegressor()  
    7. # 训练模型
    8. regressor.fit(X_train, y_train)
    9. # 回归预测
    10. y_pred = regressor.predict(X_test)
    11. df = pd.DataFrame({'Actual':y_test, 'Predicted':y_pred})  
    12. print(df.head(2))
    1.             Actual  Predicted
    2. Date                         
    3. 2017-08-09   12.83      12.63
    4. 2017-11-14   11.12      11.20

    模型评价

    1. from sklearn import metrics 
    2. # 平均绝对误差
    3. print(metrics.mean_absolute_error(
    4.     y_test, y_pred))  
    5. # 均方差
    6. print(metrics.mean_squared_error(
    7.     y_test, y_pred))
    8. # 均方根误差
    9. print(np.sqrt(
    10.     metrics.mean_squared_error(
    11.       y_test, y_pred)))
    1. 0.0924680893617
    2. 0.0226966010212
    3. 0.1506539114039

    交叉验证

    1. from sklearn.model_selection import cross_val_score
    2. dt_fit = regressor.fit(X_train, y_train)
    3. dt_scores = cross_val_score(
    4.     dt_fit, X_train, y_train, cv = 5)
    5.  
    6. print("Mean cross validation score: {}".format(np.mean(dt_scores)))
    7. print("Score without cv: {}".format(dt_fit.score(X_train, y_train)))
    1. Mean cross validation score: 0.99824909037
    2. Score without cv: 1.0

    R2

    1. from sklearn.metrics import r2_score
    2.  
    3. print('r2 score:', r2_score(y_test, dt_fit.predict(X_test)))
    4. print('Accuracy Score:', dt_fit.score(X_test, y_test))
    1. r2 score: 0.9989593390532074
    2. Accuracy Score: 0.9989593390532074

    多输出决策树回归

    多输出回归是根据输入预测两个或多个数字输出。在多输出回归中，通常，输出依赖于输入并且彼此依赖。这意味着输出经常不是彼此独立的，可能需要一个模型来预测两个输出在一起或每个输出取决于其他输出。

    一个示例说明决策树多输出回归（Decision Tree for Multioutput Regression）。

    1. X = dataset.drop(['Adj Close', 'Open'], axis=1)
    2. Y = dataset[['Adj Close', 'Open']]
    3. from sklearn.tree import DecisionTreeRegressor
    4. model = DecisionTreeRegressor()
    5. model.fit(X, Y)
    6. # 统计值
    7. # dataset.describe()
    8. # 根据统计信息输入data_in
    9. data_in = [23.98, 22.91, 7.00, 7.00, 1.62, 1.62, 4.27, 4.25]
    10. yhat = model.predict([data_in])
    11. # 预测值
    12. print(yhat[0])
    13. print(model.score(X, Y))
    1. [15.64999962 16.64999962]
    2. 1


    集成算法回归

    装袋法

    装袋法 (Bagging)的核⼼思想是构建多个 相互独⽴的评估器 ，然后对其预测进⾏平均或多数表决原则来决定集成评估器的结果。装袋法的代表模型就是随机森林。

    个体学习器间不存在强依赖关系、可同时生成的并行化方法。

    提升法

    提升法(Boosting)中，基评估器是相关的，是按顺序⼀⼀构建的。其核⼼思想是结合弱评估器的⼒量⼀次次对难以评估的样本进⾏预测，从⽽构成⼀个强评估器。提升法的代表模型Adaboost和梯度提升树GBDT。

    个体学习器间存在强依赖关系、必须串行生成的序列化方法。

    AdaBoost 回归

    AdaBoost Regressor 自适应增强回归

    通过提高那些被前一轮基学习器错误分类的样本的权值，降低那些被正确分类的样本的权值来改变训练样本分布。并对所有基学习器采用加权结合，增大分类误差小的基学习器的权值，减少分类误差率大的基学习器的权值。

    理论上的AdaBoost可以使用任何算法作为基学习器，但一般来说，使用最广泛的AdaBoost的弱学习器是决策树和神经网络。

    AdaBoost的核心原则是在反复修改的数据版本上拟合一系列弱学习者(即比随机猜测略好一点的模型，如小决策树)。他们所有的预测然后通过加权多数投票(或总和)合并产生最终的预测。

    每次所谓的增强迭代的数据修改包括对每个训练样本应用权重w_1,w_2\cdot \cdot \cdot w_n。

    1. 最初，这些权重都被设置为w_i=1/N，所以第一步仅仅是在原始数据上训练一个能力较弱的学习器。

    2. 对于每一次连续迭代，样本权值被单独修改，学习算法被重新应用到重新加权的数据。

    3. 在给定的步骤中，那些被前一步引入的增强模型错误预测的训练例子的权重增加，而那些被正确预测的训练例子的权重减少。

    4. 随着迭代的进行，难以预测的例子受到越来越大的影响。因此，每一个随后的弱学习器都被迫将注意力集中在前一个学习器错过的例子上。

    基分类器 G_m(x) 在加权数据集上的分类误差率等于被 G_m(x) 误分类样本的权重之和。

    Adaboost基本性质

    能在学习过程中不断减少训练误差，即在训练数据集上的训练误差率。且误差率是以指数数率下降的。

    1. X = dataset[['Open', 'High', 'Low', 'Volume']].values
    2. y = dataset['Buy_Sell'].values
    3. # 划分训练集与测试集略
    4. from sklearn.ensemble import AdaBoostClassifier
    5. ada = AdaBoostClassifier(n_estimators=180, random_state=0)
    6. ada.fit(X_train, y_train)
    7.  
    8. y_pred_proba = ada.predict_proba(X_test)[:,1]
    9. ada.feature_importances_
    array([ 0.18888889,0.15,0.26666667,0.39444444])

    模型评价

    1. ada.predict(X_test)
    2. ada.score(X, y)
    3. from sklearn.metrics import roc_auc_score
    4. ada_roc_auc = roc_auc_score(y_test, y_pred_proba)
    5. print('ROC AUC score: {:.2f}'.format(ada_roc_auc))

    梯度提升决策树回归 

    GBDT(Gradient Boosting Decision Tree) 又叫 MART（Multiple Additive Regression Tree)，是一种迭代的决策树算法，该算法由多棵决策树组成，所有树的结论累加起来做最终答案。它在被提出之初就和SVM一起被认为是泛化能力较强的算法。

    提升树是迭代多棵回归树来共同决策。当采用平方误差损失函数时，每一棵回归树学习的是之前所有树的结论和残差，拟合得到一个当前的残差回归树，残差的意义如公式：残差 = 真实值 - 预测值 。提升树即是整个迭代过程生成的回归树的累加。

    提升树利用加法模型和前向分步算法实现学习的优化过程。当损失函数时平方损失和指数损失函数时，每一步的优化很简单，如平方损失函数学习残差回归树。

    简单解释：每一次的计算是为了减少上一次的残差，GBDT在残差减少（负梯度）的方向上建立一个新的模型。

    提升树模型算法原理

    我们利用平方误差来表示损失函数，其中每一棵回归树学习的是之前所有树的结论和残差 ，拟合得到一个当前的残差回归树。提升树即是整个迭代过程生成的回归树的累加。

    GBDT需要将多棵树的得分累加得到最终的预测得分，且每一次迭代，都在现有树的基础上，增加一棵树去拟合前面树的预测结果与真实值之间的残差。

    梯度提升树模型算法原理

    采用向前分布算法，先确定初始提升树，然后每一次提升都是靠上次的预测结果与训练数据中标签值作为新的训练数据进行重新训练，利用损失函数的负梯度来拟合本轮损失函数的近似值，进而拟合一个CART回归树。

    对于梯度提升回归树来说，每个样本的预测结果可以表示为所有树上的结果的加权求和。

     

    GBDT正则化

    子采样比例方法: subsample（子采样），取值为(0,1]，采用的不放回采样。

    定义步长v方法来防止过拟合: Shrinkage，即在每一轮迭代获取最终学习器的时候按照一定的步长进行更新。

    GBDT分裂规则

    利用(x_i,r_{ti})来构建Cart回归树的时候，GBDT分裂会选取使得误差下降最多（如果cart树采用的是均方差作为损失，那么就是最小均方差）的特征进行分裂，如果这棵树不能拟合好，那么就要通过负梯度计算出新的残差向量来拟合新的Cart回归树

    GBDT如何做特征选择

    特征 j 的全局重要度通过特征 j 在单颗树中的重要度的平均值来衡量。

     其中，M 是树的数量。特征 j 在单颗树中的重要度（ 通过计算按这个特征i分裂之后损失的减少值 ）的如下：

    其中，L 为树的叶子节点数量，L-1 即为树的非叶子节点数量（构建的树都是具有左右孩子的二叉树），u_t 是和节点 t 相关联的特征，\hat{i}^{2}_t 是节点 t 分裂之后平方损失的减少值。

     

    优点

    • 相对少的调参时间情况下可以得到较高的准确率。

    • 可灵活处理各种类型数据，包括连续值和离散值，使用范围广。

    • 可使用一些健壮的损失函数，对异常值的鲁棒性较强，比如Huber损失函数。

    缺点

    • 弱学习器之间存在依赖关系，难以并行训练数据。

    • 需要先处理缺失值。

    1. X = dataset[['Open', 'High', 'Low', 'Volume']].values
    2. y = dataset['Adj Close'].values
    3. # 划分训练集与测试集略
    4. from sklearn.ensemble import GradientBoostingRegressor
    5. gb = GradientBoostingRegressor(max_depth=4, 
    6.             n_estimators=200,
    7.             random_state=2)
    8. # 用训练集训练数据
    9. gb.fit(X_train, y_train)
    10. # 预测测试集标签
    11. y_pred = gb.predict(X_test)
    12. from sklearn.metrics import mean_squared_error as MSE
    13. # 计算 MSE
    14. mse_test = MSE(y_test, y_pred)
    15. # 计算 RMSE
    16. rmse_test = mse_test**(1/2)
    17. # 输出 RMSE
    18. print('Test set RMSE of gb: {:.3f}'.format(rmse_test))

    模型提升 

    1. estimator_imp = tf.estimator.DNNRegressor(
    2.     feature_columns=feature_columns,
    3.     hidden_units=[300, 100],
    4.     dropout=0.3,
    5.     optimizer=tf.train.ProximalAdagradOptimizer(
    6.       learning_rate=0.01,
    7.       l1_regularization_strength=0.01, 
    8.       l2_regularization_strength=0.01
    9.     ))
    10. estimator_imp.train(input_fn = train_input,steps=1000) 
    11. estimator_imp.evaluate(eval_input,steps=None) 
    {'average_loss': 6.139895, 'global_step': 1000, 'loss': 1442.8754}

     

    随机森林回归

    随机森林采用决策树作为弱分类器，在bagging的样本随机采样基础上，⼜加上了特征的随机选择。

    当前结点特征集合（ d 个特征），随机选择 k 个特征子集，再选择最优特征进行划分。k 控制了随机性的引入程度，推荐值：k=log_2d

    对预测输出进行结合时，分类任务——简单投票法；回归任务——简单平均法

    采用有交叠的采样子集的目的

    1. 为集成中的个体学习器应尽可能相互独立，尽可能具有较大差异，以得到泛化能力强的集成。对训练样本进行采样，得到不同的数据集。

    2. 如果采样出的每个子集都完全不同，每个学习器只用到一小部分训练数据，甚至不足以进行有效学习。

    3. Bagging能不经修改的用于多分类、回归等任务。而Adaboost只适用二分类任务有 36.8% 的袋外数据用于验证集。

    算法

    1. 从样本集N中有放回随机采样选出n个样本。

    2. 从所有特征中随机选择k个特征，对选出的样本利用这些特征建立决策树(一般是CART方法)。

    3. 重复以上两步m次，生成m棵决策树，形成随机森林，其中生成的决策树不剪枝。

    4. 对于新数据，经过每棵决策树投票分类。

    随机森林的优点

    1. 决策树选择部分样本及部分特征，一定程度上避免过拟合 。

    2. 决策树随机选择样本并随机选择特征，模型具有很好的抗噪能力，性能稳定。

    3. 能够处理高维度数据，并且不用做特征选择，能够展现出哪些变量比较重要。

    4. 对缺失值不敏感，如果有很大一部分的特征遗失，仍可以维持准确度。

    5. 训练时树与树之间是相互独立的，训练速度快，容易做成并行化方法。

    6. 随机森林有袋外数据obb，不需要单独划分交叉验证集。

    随机森林的缺点

    1. 可能有很多相似决策树，掩盖真实结果。

    2. 对小数据或低维数据可能不能产生很好分类。

    3. 产生众多决策树，算法较慢。

    1. X = dataset.drop(['Adj Close', 'Close'], axis=1)  
    2. y = dataset['Adj Close']
    3.  
    4. from sklearn.model_selection import train_test_split
    5. from sklearn.preprocessing import StandardScaler
    6. X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, random_state=42)
    7.  
    8. # 数据标准化
    9. scaler = StandardScaler().fit(X_train)
    10. X_train_scaled = pd.DataFrame(scaler.transform(X_train), index=X_train.index.values, columns=X_train.columns.values)
    11. X_test_scaled = pd.DataFrame(scaler.transform(X_test), index=X_test.index.values, columns=X_test.columns.values)
    12.  
    13. # PCA降维
    14. from sklearn.decomposition import PCA
    15. pca = PCA()
    16. pca.fit(X_train)
    17. cpts = pd.DataFrame(pca.transform(X_train))
    18. x_axis = np.arange(1, pca.n_components_+1)
    19.  
    20. # 标准化后的降维
    21. pca_scaled = PCA()
    22. pca_scaled.fit(X_train_scaled)
    23. cpts_scaled = pd.DataFrame(pca.transform(X_train_scaled))

     模型建立与评价

    1. from sklearn.ensemble import RandomForestRegressor
    2. rf = RandomForestRegressor(n_estimators=500, oob_score=True, random_state=0)
    3. rf.fit(X_train, y_train)
    4. from sklearn.metrics import r2_score
    5. from scipy.stats import spearmanr, pearsonr
    6.     
    7. predicted_train = rf.predict(X_train)
    8. predicted_test = rf.predict(X_test)
    9.  
    10. test_score = r2_score(y_test, predicted_test)
    11. spearman = spearmanr(y_test, predicted_test)
    12. pearson = pearsonr(y_test, predicted_test)
    13.  
    14. print('Out-of-bag R-2 score estimate:', rf.oob_score_)
    15. print('Test data R-2 score:', test_score)
    16. print('Test data Spearman correlation:',spearman[0])
    17. print('Test data Pearson correlation:',pearson[0])
    1. Out-of-bag R-2 score estimate: 0.99895617164
    2. Test data R-2 score: 0.999300318737
    3. Test data Spearman correlation: 0.999380233068
    4. Test data Pearson correlation: 0.999650364791

    多输出随机森林回归

    1. X = dataset.drop(['Adj Close', 'Open'], axis=1)
    2. Y = dataset[['Adj Close', 'Open']]
    3. from sklearn.ensemble import RandomForestRegressor
    4.  
    5. model = RandomForestRegressor()
    6. model.fit(X, Y)
    7. data_in = [[23.98, 22.91, 7.00, 7.00, 1.62, 1.62, 4.27, 4.25]]
    8. yhat = model.predict(data_in)
    9. model.score(X, Y)
    10. print(yhat[0])
    [10.96199994 10.57600012]

    XGBoost回归

    XGBoost是boosting算法的其中一种。Boosting算法的思想是将许多弱分类器集成在一起形成一个强分类器。因为XGBoost是一种提升树模型，所以它是将许多树模型集成在一起，形成一个很强的分类器。而所用到的树模型则是CART回归树模型。

    回归树的生成步骤如下

    1. 从根节点开始分裂。

    2. 节点分裂之前，计算所有可能的特征及它们所有可能的切分点分裂后的平方误差（结构分数之差）。

    3. 如果所有的平方误差均相同或减小值小于某一阈值，或者节点包含的样本数小于某一阈值，则分裂停止；否则，选择使平方误差最小的特征和切分点作为最优特征和最优切分点进行分裂，并生成两个子节点。

    4. 对于每一个新生成的子节点，递归执行步骤2和步骤3，直到满足停止条件。

    算法原理

    不断地添加树，不断地进行特征分裂来生长一棵树，每次添加一个树，其实是学习一个新函数，去拟合上次预测的残差

    当我们训练完成得到k棵树，我们要预测一个样本的分数，其实就是根据这个样本的特征，在每棵树中会落到对应的一个叶子节点，每个叶子节点就对应一个分数

    最后只需要将每棵树对应的分数加起来就是该样本的预测值。

    XGB vs GBDT 核心区别：求解预测值的方式不同

    GBDT中  预测值是由所有弱分类器上的预测结果的加权求和 ，其中每个样本上的预测结果就是样本所在的叶子节点的均值。

    而XGBT中的  预测值是所有弱分类器上的叶子权重直接求和得到。 这个叶子权重就是所有在这个叶子节点上的样本在这一棵树上的回归取值，用或者来表示，其中表示第棵决策树， 表示样本对应的特征向量

    目标函数

    第一项是衡量我们的偏差，模型越不准确，第一项就会越大。第二项是衡量我们的方差，模型越复杂，模型的学习就会越具体，到不同数据集上的表现就会差异巨大，方差就会越大。

     代码实现

    1. X = dataset[['Open', 'High', 'Low', 'Volume']].values
    2. y = dataset['Adj Close'].values
    3. from xgboost import XGBRegressor
    4.  
    5. xgb = XGBRegressor(max_depth=5, learning_rate=0.01, n_estimators=2000, colsample_bytree=0.1)
    6. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
    7. xgb.fit(X_train,y_train)
    8. y_pred = xgb.predict(X_test)
    9. xgb.score(X_test, y_test)

     人工神经网络

    深度神经网络(DNN)回归器

    • 3层: 输入、隐藏和输出

    • 特征: 输入数据到网络(特征)

    • 标签: 网络输出(标签)

    • 损失函数: 用于估计学习阶段的性能的度量

    • 优化器: 通过更新网络中的知识来提高学习效果

    数据准备

    1. X = dataset.drop(['Adj Close', 'Close'], axis=1)  
    2. y = dataset['Adj Close'] 
    3. #  数据划分略
    4. y_train  = y_train.astype(int)
    5. y_test  = y_test.astype(int)
    6. batch_size =len(X_train)

    数据转换

    1. ## 数据归一化
    2. from sklearn.preprocessing import MinMaxScaler
    3. scaler = MinMaxScaler()
    4. # Train
    5. X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
    6. # test
    7. X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))

    tensorflow结构

    1. import tensorflow as tf
    2. feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]

    建模输

    1. estimator = tf.estimator.DNNRegressor(
    2.     feature_columns=feature_columns,
    3.     hidden_units=[300, 100])
    4.  
    5. # 训练模型
    6. train_input = tf.estimator.inputs.numpy_input_fn(
    7.     x={"x": X_train_scaled},
    8.     y=y_train,
    9.     batch_size=50,
    10.     shuffle=False,
    11.     num_epochs=None)
    12. estimator.train(input_fn = train_input,steps=1000) 
    13. eval_input = tf.estimator.inputs.numpy_input_fn(
    14.     x={"x": X_test_scaled},
    15.     y=y_test, 
    16.     shuffle=False,
    17.     batch_size=X_test_scaled.shape[0],
    18.     num_epochs=1)
    19. estimator.evaluate(eval_input,steps=None)

    输出结果

    {'average_loss': 6.4982734, 'global_step': 1000, 'loss': 1527.0942}

  • 相关阅读:
    Java -- 定时任务实现方式
    深度交流 | 能链科技兰春嘉博士受邀参加中国建设银行内训讲座
    【数据集】水文专业常用数据集整理
    Golang基础教程
    MySQL笔记(进阶篇)
    图解哈希表及其原理
    【python入门专项练习】-N03.列表
    K8s nginx-ingress 如何配置二级目录转发远程静态服务器基于Vue路由history模式打包的应用程序
    全局异常处理+JSR303验证
    pixhawk飞控和自习开发的stm32芯片通讯问题
  • 原文地址：https://blog.csdn.net/qq_39312146/article/details/134272828