精华内容
下载资源
问答
  • 本次实战为,使用一些常用的回归模型对数据集做出预测,绘制预测结果是否符合要求。 本次实战的回归模型有: Linear Regression(线性回归) Decision Tree Regressor(决策树回归) SVM Regressor(支持向量机...

    实战说明

    本次实战为,使用一些常用的回归模型对数据集做出预测,绘制预测结果是否符合要求。

    本次实战的回归模型有:

    • Linear Regression(线性回归)
    • Decision Tree Regressor(决策树回归)
    • SVM Regressor(支持向量机回归)
    • K Neighbors Regressor(K近邻回归)
    • Random Forest Regressor(随机森林回归)
    • Adaboost Regressor(Adaboost 回归)
    • Gradient Boosting Random Forest Regressor(梯度增强随机森林回归)
    • bagging Regressor(bagging 回归)
    • ExtraTree Regressor(ExtraTree 回归)

    共9种回归模型

     

    数据集

    使用自制的动态血糖监测数据作为数据集,数据维度为(4793,2)。

    数据格式为:动态血糖值,检测时间点(时间戳)


    目录

    开始

    载入相关库

    数据预处理

    使用一元线性回归检验数据集

    多元模型定义

    开始预测

    Linear Regression(线性回归)

    Decision Tree Regressor(决策树回归)

    SVM Regressor(支持向量机回归)

    K Neighbors Regressor(K近邻回归)

    Random Forest Regressor(随机森林回归)

    Adaboost Regressor(Adaboost 回归)

    Gradient Boosting Random Forest Regressor(梯度增强随机森林回归)

    Bagging Regressor(Bagging 回归)

    ExtraTree Regressor(ExtraTree 回归)

    结论

    数据集和代码


     

    开始

    载入相关库

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import seaborn as sns
    # 正常显示中文
    from pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['SimHei']
    # 正常显示符号
    from matplotlib import rcParams
    rcParams['axes.unicode_minus']=False
    
    from sklearn.pipeline import Pipeline
    from sklearn.model_selection import train_test_split
    from sklearn.linear_model import LinearRegression
    from sklearn.preprocessing import PolynomialFeatures
    

    载入模型库

    #Linear Regression
    from sklearn import linear_model
    model_LinearRegression = linear_model.LinearRegression()
    #Decision Tree Regressor
    from sklearn import tree
    model_DecisionTreeRegressor = tree.DecisionTreeRegressor()
    #SVM Regressor
    from sklearn import svm
    model_SVR = svm.SVR()
    #K Neighbors Regressor
    from sklearn import neighbors
    model_KNeighborsRegressor = neighbors.KNeighborsRegressor()
    #Random Forest Regressor
    from sklearn import ensemble
    model_RandomForestRegressor = ensemble.RandomForestRegressor(n_estimators=20)
    #Adaboost Regressor
    from sklearn import ensemble
    model_AdaBoostRegressor = ensemble.AdaBoostRegressor(n_estimators=50)
    #Gradient Boosting Random Forest Regressor
    from sklearn import ensemble
    model_GradientBoostingRegressor = ensemble.GradientBoostingRegressor(n_estimators=100)
    #bagging Regressor
    from sklearn.ensemble import BaggingRegressor
    model_BaggingRegressor = BaggingRegressor()
    #ExtraTree Regressor
    from sklearn.tree import ExtraTreeRegressor
    model_ExtraTreeRegressor = ExtraTreeRegressor()

     

    数据预处理

    载入数据集

    data = pd.read_csv('DynamicBloodGlucoseData.csv',index_col=0)
    data.head()

     

    划分数据集,分为特征(X_train)和标签(y_train)。

    X_train = data['dateline'].values.reshape(-1, 1)
    y_train = data['blood_sugar'].values

    由于时间戳的点过多,且时间戳对于血糖预测没有帮助,将时间戳转化为指定时间格式(小时分钟),因为血糖值和每天的时间点有关系。

    import time
    
    # 时间戳转字符串时间
    def  stamp2str(stamp,strTimeFormat="%Y-%m-%d %H:%M:%S"):
        """
        常用的时间格式:"%Y-%m-%d %H:%M:%S"
        参数:
        stamp:int 时间戳
        return:时间字符串
        """
        return time.strftime(strTimeFormat,time.localtime(stamp))
    
    for i in range(len(X_train)):
        X_train[i] = int(stamp2str(X_train[i],strTimeFormat="%H%M"))

    数据预处理完毕。

     

    使用一元线性回归检验数据集

    model_LinearRegression.fit(X_train,y_train)
    y_pred = model_LinearRegression.predict(X_train)
    plt.figure(figsize=(14,4))
    plt.scatter(X_train, y_train, color='g')
    plt.plot(X_train, y_pred, color='r')
    plt.xlabel('time(0000-2400)')
    plt.ylabel('blood glucose value')
    
    

    数据集基本没问题,就是一元线性回归不能成功拟合数据集的数据特征,需要使用多元化。

     

    多元模型定义

    使用PolynomialFeatures方法对特征数据进行多元化,然后使用np.linspace方法生成测试使用的线性空间进行制做回归图像。

    def model_function(regr):
        pf = PolynomialFeatures(degree=7)
        regr.fit(pf.fit_transform(X_train),y_train)
        X_predict = np.linspace(0, 2400, 1440)
        X_predict_result = regr.predict(pf.transform(X_predict.reshape(X_predict.shape[0], 1)))
        plt.figure(figsize=(14,4))
        plt.scatter(X_train, y_train, color='g')
        plt.plot(X_predict, X_predict_result, 'r-')
        plt.xlabel('time(0-24)')
        plt.ylabel('blood glucose value')

    这里先使用7元的,这个可以调整,调整到最适合的回归曲线。degree过高容易过拟合,合适即可。

     

    开始预测

    Linear Regression(线性回归)

    model_function(model_LinearRegression)

     

    Decision Tree Regressor(决策树回归)

    model_function(model_DecisionTreeRegressor)

     

    SVM Regressor(支持向量机回归)

    model_function(model_SVR)

     

    K Neighbors Regressor(K近邻回归)

    model_function(model_KNeighborsRegressor)

     

    Random Forest Regressor(随机森林回归)

    model_function(model_RandomForestRegressor)

     

    Adaboost Regressor(Adaboost 回归)

    model_function(model_AdaBoostRegressor)

     

    Gradient Boosting Random Forest Regressor(梯度增强随机森林回归)

    model_function(model_GradientBoostingRegressor)

     

    Bagging Regressor(Bagging 回归)

    model_function(model_BaggingRegressor)

     

    ExtraTree Regressor(ExtraTree 回归)

    model_function(model_ExtraTreeRegressor)

     

    结论

    从以上的模型拟合程度直观分析得出以下结果:

    • 欠拟合:Linear Regression、SVM Regressor、Adaboost Regressor
    • 过拟合:K Neighbors Regressor、Random Forest Regressor、Bagging Regressor
    • 拟合程度最好的模型:Decision Tree Regressor、Gradient Boosting Random Forest Regressor、ExtraTree Regressor

    其中Gradient Boosting Random Forest Regressor拟合程度最为优秀

    此次实战测试只使用了degree=7,如有兴趣可以尝试其他值,直到大多数模型拟合度较高时degree为最优值。

     

    数据集和代码

    代码和数据集都存在在我的github中

    本次实战的github项目地址:https://github.com/935048000/bloodGlucosePredict

    有错误欢迎大家指出,Thank you !

    展开全文
  • 常用的回归模型及其代码实现线性回归(Linear Regression)新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容...

    线性回归(Linear Regression)

    机器学习中最简单的回归模型,在一元回归模型中,形式为一元函数关系Y= Wx + b,称为单变量线性回归(Single Variable Linear Regression )。简单来说就是用一元线性模型来拟合数据关系。当然,实际运用基本都是多变量的线性回归(Multi Variable Linear Regression)(单变量高中生都能拟合了),体现了多个输入自变量(特征变量)与输出因变量之间的关系。
    多变量线性模型
    其中a是系数,b是偏置。适用于建模线性可分数据,使用权重系数a来加权每个特征变量的重要性,可以使用随机梯度(SGD)来确定这些权重。

    线性回归的特点:

    1. 建模速度快,使用建模线性关系明显且数据量不大的情况。
    2. 有非常直观的理解和解释,常用于机器学习的入门
    3. 对异常值非常敏感,建模前最好删除异常值

    线性回归的代码实现

    成本函数(Cost Function)

    使用成本函数J来表示预测结果h(x)与实际输出y之间的误差,这里可以使用最简单的“最小均方误差”(Least mean square)来描述:
    在这里插入图片描述
    其中,m表示样本的数量,i表示第i个样本,其中的1/2,是为了求导方便而添加的专业习惯。

    梯度下降(SGD)

    如上文所说,我们需要使用梯度下降确定我们的参数w=和b,使得损失函数J的值最小。
    在这里插入图片描述
    关于成本函数J的图像大致像一个“碗”(上),我们来看看J关于一个参数w1(其实应该是theta,代表权重参数)的图像
    在这里插入图片描述
    在这里插入图片描述
    所以按照一般的思路,就是对权重参数求导,使得倒数为0的参数的值,就是成本函数J取得最小值的地方。但是大多时候,求得的偏导的数学表达式很复杂,所以我们采用一种叫做“梯度下降(gradient descent)”的方法
    在这里插入图片描述
    即:

    在这里插入图片描述
    通俗一点讲,就是希望权重参数“沿着J减小的方向(梯度减小的方向),一步一步(也就是学习率alpha)的走到那个最低点”

    代码实现——使用sklearn的线性回归模型

    class LinearRegression(fit_intercept = True,normalize = False,copy_X = True,n_jobs = 1)
      """
      :param normalize:如果设置为True时,数据进行标准化。请在使用normalize = False的估计器调时用fit之前使用preprocessing.StandardScaler
     
      :param copy_X:boolean,可选,默认为True,如果为True,则X将被复制
     
      :param n_jobs:int,可选,默认1。用于计算的CPU核数
      """
    

    实例代码:

    from sklearn.linear_model import LinearRegression
    reg = LinearRegression()
    

    波士顿房价预测

    1. 波士顿房价的数据描述
    from sklearn.datasets import load_boston
    boston = load_boston()
    print(boston.DESCR)  #查看数据信息
    
    

    Boston house prices dataset

    Data Set Characteristics:

    :Number of Instances: 506 
    
    :Number of Attributes: 13 numeric/categorical predictive. Median Value (attribute 14) is usually the target.
    
    :Attribute Information (in order):
    
    1. 房价数据分割
    from sklearn.model_selection import train_test_split
    
    import numpy as np
    
    X = boston.data
    y = boston.target
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=33, test_size=0.25)
    

    3.训练与预测数据标准化处理

    from sklearn.preprocessing import StandardScaler
    
    ss_X = StandardScaler()
    ss_y = StandardScaler()
    
    X_train = ss_X.fit_transform(X_train)
    X_test = ss_X.transform(X_test)
    y_train = ss_X.fit_transform(y_train.reshape(-1, 1))
    y_test = ss_X.transform(y_test.reshape(-1, 1))
    
    1. 使用线性回归模型对房价进行预测
    from sklearn.linear_model import LinearRegression
    lr = LinearRegression()
    lr.fit(X_train,y_train)
    lr_y_predict = lr.predict(X_test)
    

    5.使用均方误差评测

    from sklearn.metrics import mean_squared_error
     
    print '线性回归模型的均方误差为:',mean_squared_error(ss_y.inverse_transform(y_test),ss_y.inverse_tranform(lr_y_predict))
    

    完整代码:

    from sklearn.linear_model import LinearRegression, SGDRegressor, Ridge
    from sklearn.preprocessing import StandardScaler
    from sklearn.datasets import load_boston
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import mean_squared_error
    
    
    
    def linearmodel():
        """
        线性回归对波士顿数据集处理
        :return: None
        """
    
        # 1、加载数据集
    
        ld = load_boston()
    
        x_train, x_test, y_train, y_test = train_test_split(ld.data, ld.target, test_size=0.25)
    
        # 2、标准化处理
    
        ss_X = StandardScaler()
        ss_y = StandardScaler()
    
        x_train = ss_X.fit_transform(x_train)
        x_test = ss_X.transform(x_test)
        y_train = ss_y.fit_transform(y_train.reshape(-1, 1))
        y_test = ss_y.transform(y_test.reshape(-1, 1))
    
        # 3、估计器流程
    
        # LinearRegression
        lr = LinearRegression()
    
        lr.fit(x_train, y_train)
    
        # print(lr.coef_)
    
        y_lr_predict = lr.predict(x_test)
    
        y_lr_predict = ss_y.inverse_transform(y_lr_predict)
    
        print("Lr预测值:", y_lr_predict)
    
        # SGDRegressor
        sgd = SGDRegressor()
    
        sgd.fit(x_train, y_train)
    
        # print(sgd.coef_)
    
        y_sgd_predict = sgd.predict(x_test)
    
        y_sgd_predict = ss_y.inverse_transform(y_sgd_predict)
    
        print("SGD预测值:", y_sgd_predict)
    
        # 带有正则化的岭回归
    
        rd = Ridge(alpha=0.01)
    
        rd.fit(x_train, y_train)
    
        y_rd_predict = rd.predict(x_test)
    
        y_rd_predict = ss_y.inverse_transform(y_rd_predict)
    
        print(rd.coef_)
    
        # 两种模型评估结果
    
        print("lr的均方误差为:", mean_squared_error(ss_y.inverse_transform(y_test), y_lr_predict))
    
        print("SGD的均方误差为:", mean_squared_error(ss_y.inverse_transform(y_test), y_sgd_predict))
    
        print("Ridge的均方误差为:", mean_squared_error(ss_y.inverse_transform(y_test), y_rd_predict))
    
    
    print(linearmodel())
    
    
    展开全文
  • 一些常用的回归模型

    万次阅读 2018-01-16 12:33:33
    线性回归在求解时,一般需要给所有样本添加一个常数项,作为回归模型的偏置 线性回归模型可以表述为 y^=hθ(x)=θTx\hat y = {h_\theta }(x) = {\theta ^T}x 该方程有封闭解,利用最小二乘法可以有 θ^=(xTx)−1x...

    线性回归模型

    线性回归

    • 线性回归在求解时,一般需要给所有样本添加一个常数项,作为回归模型的偏置
    • 线性回归模型可以表述为
      y^=hθ(x)=θTx

      该方程有封闭解,利用最小二乘法可以有
      θ^=(xTx)1xy
    %matplotlib inline
    import numpy as np
    import matplotlib.pyplot as plt
    # .T是转置,dot是矩阵乘法
    X = 2*np.random.rand(100,1)
    y = 4+3*X + np.random.randn(X.shape[0], X.shape[1])
    X_b = np.c_[np.ones(X.shape), X]
    theta_best = np.linalg.inv( X_b.T.dot( X_b ) ).dot( X_b.T ).dot(y)
    print( theta_best )
    X_new = np.array([[0], [2]])
    X_new_b = np.c_[np.ones((2,1)), X_new]
    y_predict = X_new_b.dot( theta_best )
    plt.plot( X, y, 'r.' )
    plt.plot( X_new, y_predict, 'b-' )
    plt.show()
    
    [[ 3.80963489]
     [ 3.17287426]]
    

    这里写图片描述

    • sklearn中的线性模型也可以用于求解
    • 这个线性模型在求解时,会自动给数据添加一列常数项作为偏置
    • 对于线性模型来说,数据量过大时,求解过程会变得非常长,因为X矩阵变大了
    • 在对线性模型进行预测的时候,预测的时间只与要预测的变量成正比

      python
      from sklearn.linear_model import LinearRegression
      lin_reg = LinearRegression()
      lin_reg.fit( X, y )
      b = lin_reg.intercept_
      k = lin_reg.coef_
      print(k, b)
      print( lin_reg.predict( X_new ) )

      [[ 3.17287426]] [ 3.80963489]
      [[ 3.80963489]
      [ 10.15538341]]

    梯度下降(Gradient Descend)

    • 梯度下降的目标是最小化代价函数,当代价函数是凸函数的时候,梯度下降会有唯一解,权重更新的公式为
      θMSE(θ)=2mXT(Xθy)

      θ(next_step)=θηθMSE(θ)

      其中η是学习率
    • 学习率太大,容易发生震荡,学习率太小,达到最优解的速度太慢,需要根据情况选择合适的学习率
    • 如果使用上面的梯度下降方法(批量梯度下降BGD)进行训练,则每次训练的时候会使用全部的训练集数据,对于数据量很大的训练集来说,这种训练方法过于耗时,因此可以采用一种随机梯度下降(SGD)的方法,每次只采用一个训练样本进行梯度下降
    • 如果代价函数有局部最小值,而不是全局最小值,则BGD一般难以跳出局部最优,而SGD常常可以跳出全局最优
    • BGD一般到达最优解之后很少跳动,而SGD一般在到达最优解之后仍然会小幅跳动,即它可以保证解较好,但是不一定是最优的
    • 动态的学习率可以使的在迭代初期,模型快速收敛,在迭代的后期,模型可以在最优解附近以很小的步长寻找最优解
    • 不同于以上只采用一个训练样本进行训练的SGD方法,**Mini-batch G**D是在每次迭代中随机选择部分的训练样本,这样的话可以通过使用GPU大大加快GD训练的速度,同时到达最优解的稳定性也比SGD要好
    # BGD代码
    eta = 0.1
    n_iterations = 500
    m = X_b.shape[0]
    theta = np.random.randn( 2, n_iterations)
    
    for iteration in range(1,n_iterations):
        gradients = 2/m * X_b.T.dot( X_b.dot(theta[:,iteration-1:iteration]) - y )
        theta[:,iteration:iteration+1] = theta[:,iteration-1:iteration] - eta * gradients
    plt.plot( theta.T )
    plt.show()
    

    这里写图片描述

    # 动态学习指数的SGD
    n_epochs = 50
    t0, t1 = 5, 50
    
    all_theta = np.zeros((2, n_epochs))
    theta = np.random.randn(2,1)
    
    def learning_schedule(t):
        return t0 / ( t + t1 )
    
    for epoch in range( n_epochs ):
        for i in range(m):
            random_index = np.random.randint(m)
            xi = X_b[random_index:random_index+1]
            yi = y[random_index:random_index+1]
            gradients = 2* xi.T.dot( xi.dot(theta) - yi )
            eta = learning_schedule(epoch*m+i)
            theta = theta - eta*gradients
        all_theta[:,epoch:epoch+1] = theta
    print( theta )
    plt.plot( all_theta.T )
    plt.show()
    [[ 4.09826145]
     [ 3.16957123]]
    

    这里写图片描述

    # sklearn自带的SGD回归
    from sklearn.linear_model import SGDRegressor
    sgd_reg = SGDRegressor(max_iter=50, penalty=None, eta0=0.1)
    # SGD要求y是一个1d的矩阵
    sgd_reg.fit( X, y.ravel() )
    print( sgd_reg.intercept_ )
    print( sgd_reg.coef_ )
    
    [ 3.79193051]
    [ 3.15907091]
    

    多项式回归

    • 上述所有内容均是真对线性模型,如果y与x有非常明显的非线性关系,则可能需要用到非线性回归,如多项式回归,通用多项式回归方程如下
      y=anxn+an1xn1++a0
    • 我们可以首先构建出[xn,xn1,,x],然后进行线性回归即可
    • 在进行多项式回归时,如果阶次选的太大,很容易发生过拟合现象,即训练误差远小于测试(或者验证)误差
    from sklearn.preprocessing import PolynomialFeatures
    m = 100
    X = 6 * np.random.rand(m,1) - 3
    y = 0.5 * X**2 + X + 2 + np.random.randn(m, 1)
    
    poly_features = PolynomialFeatures( degree=2, include_bias=False )
    X_poly = poly_features.fit_transform( X )
    print( X[0], X_poly[0] )
    
    lin_reg = LinearRegression()
    lin_reg.fit( X_poly, y )
    print( lin_reg.intercept_, lin_reg.coef_ )
    
    # min是找出矩阵最小值,argmin是找出矩阵最小值所在的index
    X_pred = np.linspace( np.min(X), np.max(X), 50 )
    # coef所对应的阶数是从1往n排的
    y_poly_pred = lin_reg.coef_[0,1] * X_pred**2 + lin_reg.coef_[0,0] * X_pred + lin_reg.intercept_
    
    plt.plot( X, y, 'r+' )
    plt.plot( X_pred, y_poly_pred, 'b-' )
    plt.show()
    [-0.59004635] [-0.59004635  0.3481547 ]
    [ 2.32067214] [[ 1.02368889  0.42819181]]
    

    这里写图片描述

    from sklearn.metrics import mean_squared_error
    from sklearn.model_selection import train_test_split
    
    def plot_learning_curves(model, X, y):
        X_train, X_val, y_train, y_val = train_test_split( X, y, test_size=0.2 )
        train_errors, val_errors = [], []
        for m in range(1, len(X_train)):
            model.fit( X_train[:m], y_train[:m] )
            y_train_predict = model.predict( X_train[:m] )
            y_val_predict = model.predict( X_val )
            train_errors.append( mean_squared_error( y_train_predict, y_train[:m] ) )
            val_errors.append( mean_squared_error( y_val_predict, y_val ) )
        plt.plot( np.sqrt(train_errors), "r-+", label="train" )
        plt.plot( np.sqrt(val_errors), "b-", label="validation" )
        plt.legend()
    
    lin_reg = LinearRegression()
    plot_learning_curves( lin_reg, X, y )
    plt.show()

    这里写图片描述

    from sklearn.pipeline import Pipeline
    polynomial_reg = Pipeline( (("poly_features", PolynomialFeatures(degree=10, include_bias=False)),
                               ("sgd_reg", LinearRegression()), ))
    plot_learning_curves( polynomial_reg, X, y )

    这里写图片描述

    过拟合与欠拟合

    • 机器学习中模型的误差可以用偏差、方差或者不可约束的误差进行描述,如果一个模型的偏差(bias)很大,则一般认为该模型是欠拟合的;如果一个模型的方差(variance)很大,则一般认为这个模型是过拟合的;不可约束的误差来源于数据本身,减小它的方式只有数据清洗
    • 增加模型的复杂度可以增大一个模型的方差,降低其偏差。因此一般需要对模型进行折衷考虑。

    正则化(Regularized Lineral Models)

    • 为了减小模型过拟合的程度,可以引入惩罚线性回归,即对线性模型的参数进行限制。这就是正则化线性模型,又称为惩罚线性模型。有4种常用的正则化模型
    • 下面两种模型中的α都是惩罚项的系数,为0时,化简为单纯的线性回归模型;为时,表示模型只受到参数项的影响

    岭回归

    • 岭回归的代价函数是
      J(θ)=MSE(θ)+12αi=1nθ2i

      封闭解为
      θ^=(XTX+αA)1XTy

    Lasso回归

    • 岭回归的代价函数是
      J(θ)=MSE(θ)+αi=1n|θi|

    弹性网络(Elastic Net)

    • 弹性网络是将岭回归与Lasso回归的代价函数进行加权平均,引入一个权重rr=0时,只有岭回归起作用;r=1时,只有Lasso回归起作用。
      J(θ)=MSE(θ)+αri=1n|θi|1r2αi=1nθ2i

    Early Stopping

    • Early Stopping指的是迭代学习训练,如果GD,只要验证集误差到达极小值,立刻停止训练
    • SGDRegressor中的warm_start设置为true时,表示每次调用fit时,都会在之前的参数的基础上进行训练,而不是用随机初始参数进行训练
    from sklearn.linear_model import Ridge
    from sklearn.preprocessing import StandardScaler
    # X = np.linspace(-3, 3, 20).reshape(20,1)
    # y = 2 * X + 1 + np.random.randn(X.shape[0], 1)
    
    plt.subplot(121)
    plt.plot(X, y, 'r+')
    for a in [0, 50, 100]:
        ridge_reg = Ridge( alpha=a, solver="cholesky" )
        ridge_reg.fit( X, y )
        x_pred = np.linspace( np.min(X), np.max(X), 50 ).reshape((50, 1))
        y_pred = ridge_reg.predict( x_pred )
        plt.plot( x_pred, y_pred, label="alpha = %d" % a )
    
    plt.legend()
    poly_10 = PolynomialFeatures(degree=10, include_bias=False)
    plt.subplot(122)
    plt.plot(X, y, 'r+')
    for a in [0, 10, 1000]:
        ridge_reg = Ridge( alpha=a, solver="cholesky" )
        x_pred = np.linspace( np.min(X), np.max(X), 100 ).reshape((100, 1))
        model = Pipeline([
                    ("poly_features", PolynomialFeatures(degree=10, include_bias=False)),
                    ("std_scaler", StandardScaler()),
                    ("regul_reg", ridge_reg),
                ])
    
        model.fit( X, y )
        y_pred = model.predict( x_pred )
        plt.plot( x_pred, y_pred, label="alpha = %d" % a )
    
    plt.legend()
    plt.show()
    

    这里写图片描述

    from sklearn.linear_model import Lasso
    plt.subplot(121)
    plt.plot(X, y, 'r+')
    for a in [0, 50, 100]:
        ridge_reg = Ridge( alpha=a, solver="cholesky" )
        ridge_reg.fit( X, y )
        x_pred = np.linspace( np.min(X), np.max(X), 50 ).reshape((50, 1))
        y_pred = ridge_reg.predict( x_pred )
        plt.plot( x_pred, y_pred, label="alpha = %d" % a )
    
    plt.legend()
    poly_10 = PolynomialFeatures(degree=10, include_bias=False)
    plt.subplot(122)
    plt.plot(X, y, 'r+')
    for a in [0, 0.1, 2]:
        lasso_reg = Lasso( alpha=a, tol=1e-4 )
        x_pred = np.linspace( np.min(X), np.max(X), 100 ).reshape((100, 1))
        model = Pipeline([
                    ("poly_features", PolynomialFeatures(degree=10, include_bias=False)),
                    ("std_scaler", StandardScaler()),
                    ("regul_reg", lasso_reg),
                ])
    
        model.fit( X, y )
        y_pred = model.predict( x_pred )
        plt.plot( x_pred, y_pred, label="alpha = %d" % a )
    
    plt.legend()
    plt.show()
    
    E:\InstallFolders\Anaconda342\lib\site-packages\sklearn\pipeline.py:250: UserWarning: With alpha=0, this algorithm does not converge well. You are advised to use the LinearRegression estimator
      self._final_estimator.fit(Xt, y, **fit_params)
    E:\InstallFolders\Anaconda342\lib\site-packages\sklearn\linear_model\coordinate_descent.py:477: UserWarning: Coordinate descent with no regularization may lead to unexpected results and is discouraged.
      positive)
    E:\InstallFolders\Anaconda342\lib\site-packages\sklearn\linear_model\coordinate_descent.py:491: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems.
      ConvergenceWarning)
    

    这里写图片描述

    from sklearn.linear_model import ElasticNet
    elastic_nmet = ElasticNet( alpha=0.1, l1_ratio=0.5 )
    elastic_nmet.fit( X, y )
    res = elastic_nmet.predict( [[1.5]] )
    print( res )
    [ 5.11098612]
    
    from sklearn.base import clone
    poly_scaler = Pipeline([
            ("poly_features", PolynomialFeatures(degree=90, include_bias=False)),
            ("std_scaler", StandardScaler()),
        ])
    
    X_train_poly_scaled = poly_scaler.fit_transform(X_train)
    X_val_poly_scaled = poly_scaler.fit_transform(X_val)
    sgd_reg = SGDRegressor( max_iter=1, warm_start=True, penalty=None, learning_rate="constant", eta0=5e-4 )
    
    minimum_val_error = float( "inf" )
    best_epoch = None
    best_model = None
    all_errors = []
    for epoch in range(1000):
        sgd_reg.fit( X_train_poly_scaled, y_train.ravel() )
        y_val_predict = sgd_reg.predict( X_val_poly_scaled )
        val_error = mean_squared_error( y_val_predict, y_val )
        all_errors.append( val_error )
        if val_error < minimum_val_error:
            minimum_val_error = val_error
            best_epoch = epoch
            best_model = clone( sgd_reg )
    
    plt.plot( all_errors )
    plt.show()

    这里写图片描述

    Logistic回归

    • Logisitic回归指的是将分类问题视为回归问题,即将样本属于某个类别的问题化为属于某个类别的概率问题,获得最大概率的类别就是样本所属的类别。

    估计概率(Estimating Probabilities)

    p^=hθ(x)=σ(θTx)

    σ()是sigmoid函数,取值在(0,1)之间
    σ(t)=11+et

    Logistic回归模型预测
    y^={0,ifp^<0.5,1,ifp^0.5.

    * Logistic回归模型中,一个样本(instance)的训练代价函数为
    y^={log(p^),ify=1,log(1p^),ify=0.

    因此Logistic回归代价函数为
    J(θ)=1mi=1m[y(i)log(p^(i))+(1y(i))log(1p^(i))]

    利用链式法则,对齐求偏导数,得到
    θjJ(θ)=1mi=1m(σ(θTx(i))y(i))x(i)j

    因此利用GD方法就可以进行求解

    决策边界(Decision Boundaries)

    • 虽然Logistic回归无法通过选择阈值来直接输出预测值,但是我们可以首先返回概率值,再手动选择阈值即可

    Softmax回归

    • Logistic回归常用于二分类的回归,当类别多于两个分类时(多分类问题),模型称为Softmax回归多项式Logisitic回归
    • 对于样本x,其关于类k的得分为
      sk(x)=θTkx

      将其归一化,得到样本k的归一化得分为
      p^k=σ(s(x))k=exp(sk(x))j=1Kexp(sj(x))

      其中K是类别的个数,s(x)是x关于每一类的得分向量,σ(s(x))k是样本属于类别k的估计概率,最终最大概率所属的类别就是样本所属类别的预测结果
    • Softmax回归的代价函数为
      J(θ)=1mi=1mk=1Ky(i)klog(p^(i)k)

      偏导数为
      θkJ(θ)=1mi=1m(p(i)ky(i)k)x(i)
    • Softmax回归中,当solver设置为lbfgs时,表示采用权重衰减的Softmax回归
    • 参考文献:http://deeplearning.stanford.edu/wiki/index.php/Softmax%E5%9B%9E%E5%BD%92
    • 推导偏微分的参考链接:http://www.cnblogs.com/Deep-Learning/p/7073744.html
      • 注:主要是估计概率的偏微分过程,将所有的yij,即标签值,化为1和0,简化其中一项的微分过程。
    from sklearn.linear_model import LogisticRegression
    from sklearn import datasets
    iris = datasets.load_iris()
    # print( iris["DESCR"] )
    X = iris["data"][:,3:] # petal width
    y = (iris["target"] == 2).astype(np.int)  # binarize
    
    log_reg = LogisticRegression()
    log_reg.fit( X, y )
    X_new = np.linspace( 0, 5, 1000 ).reshape(-1, 1)
    y_proba = log_reg.predict_proba( X_new ) # 得到的是一个NX2的矩阵,每一行表示属于0和1的概率
    plt.plot( X_new, y_proba[:,1], "g-", label="Iris-Virginica" ) 
    plt.plot( X_new, y_proba[:,0], "b--", label="Not Iris-Virginica" )
    plt.legend(loc="center left")
    plt.show()

    这里写图片描述

    X = iris.data[:,(2,3)]
    y = iris.target
    
    softmax_reg = LogisticRegression( multi_class="multinomial", solver="lbfgs", C=10 )
    softmax_reg.fit(X, y)
    
    res = softmax_reg.predict( [[5, 2]] )
    print(res)
    res = softmax_reg.predict_proba( [[5, 2]] )
    print(res)
    [2]
    [[  6.33134077e-07   5.75276067e-02   9.42471760e-01]]
    
    展开全文
  • 对于回归而言,更注重模型拟合曲线,相对于真实曲线误差。主要包括:拟合优度/R-Squared,校正决定系数(Adjusted R-square),均方误差(MSE),均方根误差(RMSE),误差平方和(SSE),平均绝对误差(MAE),...

    对于回归而言,模型性能的好坏主要体现在拟合的曲线与真实曲线的误差。主要的评价指标包括:拟合优度/R-Squared,校正决定系数(Adjusted R-square),均方误差(MSE),均方根误差(RMSE),误差平方和(SSE),平均绝对误差(MAE),平均绝对百分比误差(MAPE)。

    1、均方误差(MSE)

    均方误差是指:观测值与真值偏差的平方和与观测次数的比值
    公式:
    在这里插入图片描述
    MSE相当于模型中的损失函数,线性回归过程中尽量让该损失函数最小。那么模型之间的对比也可以用它来比较。MSE可以评价模型的预测精度,MSE的值越小,说明预测模型对于目标的拟合程度越精确。

    2、均方根误差(RMSE)

    RMSE(Root Mean Squard Error)均方根误差,RMSE其实是MSE开根号,两者实质一样,但RMSE能更好的描述数据。因为MSE单位量级和误差的量级不一样,而RMSE跟数据是一个级别的,更容易感知数据。
    缺点:易受异常值的影响。

    公式:
    在这里插入图片描述

    3、平均绝对误差(MAE)

    MAE(Mean Absolute Error)
    公式:
    在这里插入图片描述

    4、平均绝对百分比误差(MAPE)

    平均绝对百分比误差(Mean Absolute Percentage Error),与RMSE相比,更加鲁棒,因为MAPE对每个点的误差进行了归一化。
    公式:
    在这里插入图片描述

    5、拟合优度/R-Squared

    拟合优度是指回归直线对观测值的拟合程度。
    公式:
    在这里插入图片描述
    R2 越接近于1,说明回归直线对观测值的拟合程度越好;相反,R2值越小,说明回归直线对观测值的拟合程度越差。

    6、校正决定系数(Adjusted R-square)

    公式:
    在这里插入图片描述
    其中,n为样本数量,p为特征数量。
    取值范围还是负无穷到1,大多是 0~1,且越大越好

    展开全文
  • 数据挖掘--常用的回归模型调参总结

    千次阅读 2018-04-21 14:27:00
    1、设定一个稍大学习率(0.1),利用xgboost里cv方法去确定一个合适迭代次数(也就是树个数) 2、根据参数重要性,分别对参数进行调参,利用GridSearchCV,先进行大范围粗调再小范围精调,参数重要性排序...
  • 常用的三种线性模型算法–线性回归模型、岭回归模型、套索回归模型 线性模型基本概念 线性模型的一般预测模型是下面这个样子的,一般有多个变量,也可以称为多个特征x1、x2、x3 … 最简单的线性模型就是一条直线...
  • 常用的线性回归模型小结

    千次阅读 2017-04-23 22:52:58
    先明确几个概念:方差指是模型之间差异,偏差指是模型预测值和数据之间差异。最小二乘法线性回归(Oridinary Least Squares, OLS)线性回归拟合具有系数w =(w_1,…,w_p)线性模型,最小...线性回归模型
  • 数学建模常用模型05 :多元回归模型

    万次阅读 多人点赞 2018-08-03 13:43:37
    所以在遇到有些无法用机理分析建立数学模型时候,通常采取搜集大量数据办法,基于对数据统计分析去建立模型,其中用途最为广泛一类随即模型就是统计回归模型回归模型确定变量之间是相关关系,在大量...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,566
精华内容 1,026
关键字:

常用的回归模型