精华内容
下载资源
问答
  • 在一阶多项式线性回归中,y = a1 x + a0。 使用偏导数从 e = y - a1 x - a0 驱动 a1 和 a0: a1 = (n*sum_xy - sum_x*sum_y)/(n*sum_x2 - sum_x^2) 如果应该表示数据(线)的方程通过原点会怎样? 即y = a1 x,并且...
  • 多项式线性回归总结

    千次阅读 2018-09-02 22:44:31
    这里主要记录多项式线性回归,会附带一部分简单线性回归的讲解 线性回归其实是典型的参数训练的机器学习方法,而且专门解决回归问题 首先先讲下简单线性回归 简单线性回归 函数表达式 y=ax+b 其中 代码实现...

    这里主要记录多项式线性回归,会附带一部分简单线性回归的讲解

    线性回归其实是典型的参数训练的机器学习方法,而且专门解决回归问题

    首先先讲下简单线性回归

    简单线性回归

    函数表达式

    y=ax+b

    其中

    代码实现

    import numpy as np
    import matplotlib.pyplot as plt
    
    
    class SimpleLinearRegression:
        def __init__(self):
            self.a_ = None
            self.b_ = None
    
        #模型训练
        def fit(self, x, y):
            assert x.ndim == 1, "illegle x"
            assert len(x) == len(y), "this size of x_train must be equal to the size of y_train"
            num = 0
            d = 0
            # 用for循环耗时长,需要消耗大量的计算资源
            # for x_i, y_i in zip(x, y):
            #     num += (x_i - np.mean(x))*(y_i - np.mean(y))
            #     d += (x_i - np.mean(x))**2
            # 用向量点乘的方式可以让运算时长变短
            num = (x-np.mean(x)).dot(y-np.mean(y))
            d = (x-np.mean(x)).dot(x-np.mean(x))
    
            self.a_ = num/d
            self.b_ = np.mean(y) - self.a_* np.mean(x)
    
            return self
    
        #数据预测
        def predict(self, x):
            assert x.ndim == 1, "illegle x"
            assert self.a_ is not None and self.b_ is not None, "must fit before predict"
            y_predict = [self.__predict(x_i) for x_i in x]
            return y_predict
    
        #私有函数,单个数据的预测
        def __predict(self, x):
            return self.a_* x + self.b_
    
        def __repr__(self):
            print("this is the SimpleLinearRegression")

    多项式回归函数

    函数表达式

    整理一下变成如下

    其中

    代码如下

    import numpy as np
    from .Mertristics import Mertristics
    class LinearRegression:
        def __init__(self):
            self.coef_ = None
            self.interception_ = None
            self.theta_ = None
    
        #训练模型
        def fit(self, x_trains, y_trains):
            assert x_trains.shape[0] == len(y_trains), \
                "the size of x_trains must be equal to the size of y_trians"
    
            X_b = np.hstack([np.ones([len(x_trains), 1]), x_trains])
            self.theta_ = ((np.linalg.inv(X_b.T.dot(X_b))).dot(X_b.T)).dot(y_trains)
            self.coef_ = self.theta_[0]
            self.interception_ = self.theta_[1:]
            return self
    
        #预测数据
        def predict(self, x_test):
            assert self.coef_ is not None and self.interception_ is not None, \
                "do predict must to do fit first"
    
            X_b = np.hstack([np.ones([len(x_test), 1]), x_test])
            return X_b.dot(self.theta_)
    
        def score(self, x_test, y_test):
            y_predict = self.predict(x_test)
            #return y_predict
            metristics = Mertristics()
            return metristics.r2_score(y_test, y_predict)
    
        def __repr__(self):
            return "LinearRegression"

    关于多项式线性方程,我发现有个blog记录的笔记不错,转载一下,blog地址:https://blog.csdn.net/ayangann915/article/details/81184398

     

    展开全文
  • 本文主要总结了解决非线性回归问题的机器学习方法,其中包括多项式线性模型、广义线性(GAM)模型、回归树模型、支持向量回归(SVR)模型,每个模型的方法都有其特点。 多项式线性模型和GAM模型侧重于经验风险误差最小...

    前言

    本文主要总结了解决非线性回归问题的机器学习方法,其中包括多项式线性模型、广义线性(GAM)模型、回归树模型、支持向量回归(SVR)模型,每个模型的方法都有其特点。

    多项式线性模型和GAM模型侧重于经验风险误差最小化,容易过拟合;回归树模型和SVR模型侧重于结构风险最小化,对异常值数据更不敏感,回归树模型可通过剪枝和压缩的方式去降低过拟合的风险,SVR模型具有较好的区间内鲁棒能力。

    多项式回归模型

    概念解释:

    • 为了体现因变量和特征的非线性关系,一个很自然而然的想法就是将标准的线性回归模型:
      y i = w 0 + w 1 x i + ϵ i y_i = w_0 + w_1x_i + \epsilon_i yi=w0+w1xi+ϵi
      换成一个多项式函数:
      y i = w 0 + w 1 x i + w 2 x i 2 + . . . + w d x i d + ϵ y_i = w_0 + w_1x_i + w_2x_i^2 + ...+w_dx_i^d + \epsilon yi=w0+w1xi+w2xi2+...+wdxid+ϵ

    • 对于多项式的阶数d不能取过大,一般不大于3或者4,因为d越大,多项式曲线就会越光滑,在X的边界处有异常的波动。

    在这里插入图片描述

    sklearn实现多项式回归模型:

    sklearn.preprocessing.PolynomialFeatures(): 创建多项式回归模型。

    • 参数:
      degree:特征转换的阶数。
      interaction_onlyboolean:是否只包含交互项,默认False 。
      include_bias:是否包含截距项,默认True。
      order:str in {‘C’, ‘F’}, default ‘C’,输出数组的顺序。
    from sklearn.preprocessing import PolynomialFeatures
    X_arr = np.arange(6).reshape(3, 2)
    print("原始X为:\n",X_arr)
    
    poly = PolynomialFeatures(2)
    print("2次转化X:\n",poly.fit_transform(X_arr))
    
    poly = PolynomialFeatures(interaction_only=True)
    print("2次转化X:\n",poly.fit_transform(X_arr))
    

    广义线性可加(GAM)模型

    概念解释:

    • 广义可加模型GAM实际上是线性模型推广至非线性模型的一个框架,在这个框架中,每一个变量都用一个非线性函数来代替,但是模型本身保持整体可加性。GAM模型不仅仅可以用在线性回归的推广,还可以将线性分类模型进行推广。具体的推广形式是:
      标准的线性回归模型:
      y i = w 0 + w 1 x i 1 + . . . + w p x i p + ϵ i y_i = w_0 + w_1x_{i1} +...+w_px_{ip} + \epsilon_i yi=w0+w1xi1+...+wpxip+ϵi
      GAM模型框架:
      y i = w 0 + ∑ j = 1 p f j ( x i j ) + ϵ i y_i = w_0 + \sum\limits_{j=1}^{p}f_{j}(x_{ij}) + \epsilon_i yi=w0+j=1pfj(xij)+ϵi

    在这里插入图片描述

    pygam实现广义线性可加模型:

    pygam.LinearGAM():创建广义线性可加模型。

    • 参数:

      terms:表达式指定要建模的术语,可选。
      max_iter:允许求解器收敛的最大迭代次数。
      tol:停止标准的容忍误差。

    from pygam import LinearGAM
    model = LinearGAM()
    gam = model.fit(x, y)
    print(model.summary())
    print(gam.accuracy(X, y))
    

    GAM模型的优点与不足:

    • 优点:简单容易操作,能够很自然地推广线性回归模型至非线性模型,使得模型的预测精度有所上升;由于模型本身是可加的,因此GAM还是能像线性回归模型一样把其他因素控制不变的情况下单独对某个变量进行推断,极大地保留了线性回归的易于推断的性质

    • 缺点:GAM模型会经常忽略一些有意义的交互作用,比如某两个特征共同影响因变量,不过GAM还是能像线性回归一样加入交互项 x ( i ) × x ( j ) x^{(i)} \times x^{(j)} x(i)×x(j)的形式进行建模;但是GAM模型本质上还是一个可加模型,如果我们能摆脱可加性模型形式,可能还会提升模型预测精度,详情请看后面的算法。

    回归树模型

    概念解释:

    • 依据分层和分割的方式将特征空间划分为一系列简单的区域。

    • 用所属区域中训练集的平均数或者众数对其进行预测。

    • 决策树由结点(node)和有向边(directed edge)组成,结点有两种类型:内部结点(internal node)和叶结点(leaf node),内部结点(红框)表示一个特征或属性,叶结点(蓝框)表示一个类别或者某个值。

      在这里插入图片描述

    算法流程:

    • 1.将自变量的特征空间(即 x ( 1 ) , x ( 2 ) , x ( 3 ) , . . . , x ( p ) x^{(1)},x^{(2)},x^{(3)},...,x^{(p)} x(1),x(2),x(3),...,x(p))的可能取值构成的集合分割成J个互不重叠的区域 R 1 , R 2 , . . . , R j R_1,R_2,...,R_j R1,R2,...,Rj

    • 2.对落入区域 R j R_j Rj的每个观测值作相同的预测,预测值等于 R j R_j Rj上训练集的因变量的简单算术平均
      a. 选择最优切分特征j以及该特征上的最优点s:
      遍历特征j以及固定j后遍历切分点s,选择使得下式最小的(j,s) m i n j , s [ m i n c 1 ∑ x i ∈ R 1 ( j , s ) ( y i − c 1 ) 2 + m i n c 2 ∑ x i ∈ R 2 ( j , s ) ( y i − c 2 ) 2 ] min_{j,s}[min_{c_1}\sum\limits_{x_i\in R_1(j,s)}(y_i-c_1)^2 + min_{c_2}\sum\limits_{x_i\in R_2(j,s)}(y_i-c_2)^2 ] minj,s[minc1xiR1(j,s)(yic1)2+minc2xiR2(j,s)(yic2)2]
      b. 按照(j,s)分裂特征空间: R 1 ( j , s ) = { x ∣ x j ≤ s } 和 R 2 ( j , s ) = { x ∣ x j > s } , c ^ m = 1 N m ∑ x ∈ R m ( j , s ) y i ,    m = 1 , 2 R_1(j,s) = \{x|x^{j} \le s \}和R_2(j,s) = \{x|x^{j} > s \},\hat{c}_m = \frac{1}{N_m}\sum\limits_{x \in R_m(j,s)}y_i,\;m=1,2 R1(j,s)={xxjs}R2(j,s)={xxj>s},c^m=Nm1xRm(j,s)yi,m=1,2
      c. 继续调用步骤1,2直到满足停止条件,就是每个区域的样本数小于等于阈值个数
      d. 将特征空间划分为j个不同的区域,生成回归树: f ( x ) = ∑ m = 1 J c ^ m I ( x ∈ R m ) f(x) = \sum\limits_{m=1}^{J}\hat{c}_mI(x \in R_m) f(x)=m=1Jc^mI(xRm)

    sklearn实现回归树模型:

    sklearn.tree.DecisionTreeRegressor(): 创建回归树模型。

    • 参数说明:

      criterion:{“ mse”,“ friedman_mse”,“ mae”},默认=“ mse”。衡量分割标准的函数 。
      splitter:{“best”, “random”}, default=”best”。分割方式。
      max_depth:树的最大深度。
      min_samples_split:拆分内部节点所需的最少样本数,默认是2。
      min_samples_leaf:在叶节点处需要的最小样本数。默认是1。
      min_weight_fraction_leaf:在所有叶节点处(所有输入样本)的权重总和中的最小加权分数。如果未提供sample_weight,则样本的权重相等。默认是0。

    from sklearn.tree import DecisionTreeRegressor    
    reg_tree = DecisionTreeRegressor(criterion = "mse",min_samples_leaf = 5)
    reg_tree.fit(X,y)
    reg_tree.score(X,y)
    

    回归树与线性模型的比较:

    线性模型的模型形式与树模型的模型形式有着本质的区别,具体而言,线性回归对模型形式做了如下假定: f ( x ) = w 0 + ∑ j = 1 p w j x ( j ) f(x) = w_0 + \sum\limits_{j=1}^{p}w_jx^{(j)} f(x)=w0+j=1pwjx(j),而回归树则是 f ( x ) = ∑ m = 1 J c ^ m I ( x ∈ R m ) f(x) = \sum\limits_{m=1}^{J}\hat{c}_mI(x \in R_m) f(x)=m=1Jc^mI(xRm)。那问题来了,哪种模型更优呢?

    • 这个要视具体情况而言,如果特征变量与因变量的关系能很好的用线性关系来表达,那么线性回归通常有着不错的预测效果,拟合效果则优于不能揭示线性结构的回归树。反之,如果特征变量与因变量的关系呈现高度复杂的非线性,那么树方法比传统方法更优

    树模型的优缺点:

    • 树模型的解释性强,在解释性方面可能比线性回归还要方便。
    • 树模型更接近人的决策方式。
    • 树模型可以用图来表示,非专业人士也可以轻松解读
    • 树模型可以直接做定性的特征而不需要像线性回归一样哑元化。
    • 树模型能很好处理缺失值和异常值,对异常值不敏感,但是这个对线性模型来说却是致命的
    • 树模型的预测准确性一般无法达到其他回归模型的水平,但是改进的方法很多。

    支持向量回归(SVR)模型

    概念解释:

    • 支持向量回归(SVR)是采用一个以f(x) =wTx+b为中心,宽度为2ε的间隔带,来拟合训练样本。

    • 落在带子上的样本不计算损失(类比线性回归在线上的点预测误差为0),不在带子上的则以偏离带子的距离作为损失(类比线性回归的均方误差) ,然后以最小化损失的方式迫使间隔带从样本最密集的地方(中心地带)穿过,进而达到拟合训练样本的目的

    在这里插入图片描述

    算法流程:

    m i n w , b , ξ i , ξ ^ i 1 2 ∣ ∣ w ∣ ∣ 2 + C ∑ i = 1 N ( ξ i , ξ ^ i ) s . t .        f ( x i ) − y i ≤ ϵ + ξ i            y i − f ( x i ) ≤ ϵ + ξ ^ i            ξ i , ξ ^ i ≤ 0 , i = 1 , 2 , . . . , N min_{w,b,\xi_i,\hat{\xi}_i} \frac{1}{2}||w||^2 +C \sum\limits_{i=1}^{N}(\xi_i,\hat{\xi}_i)\\ s.t.\;\;\; f(x_i) - y_i \le \epsilon + \xi_i\\ \;\;\;\;\;y_i - f(x_i) \le \epsilon +\hat{\xi}_i\\ \;\;\;\;\; \xi_i,\hat{\xi}_i \le 0,i = 1,2,...,N minw,b,ξi,ξ^i21w2+Ci=1N(ξi,ξ^i)s.t.f(xi)yiϵ+ξiyif(xi)ϵ+ξ^iξi,ξ^i0,i=1,2,...,N
    ​ 引入拉格朗日函数:
    L ( w , b , α , α ^ , ξ , ξ , μ , μ ^ ) = 1 2 ∥ w ∥ 2 + C ∑ i = 1 N ( ξ i + ξ ^ i ) − ∑ i = 1 N ξ i μ i − ∑ i = 1 N ξ ^ i μ ^ i + ∑ i = 1 N α i ( f ( x i ) − y i − ϵ − ξ i ) + ∑ i = 1 N α ^ i ( y i − f ( x i ) − ϵ − ξ ^ i ) \begin{array}{l} L(w, b, \alpha, \hat{\alpha}, \xi, \xi, \mu, \hat{\mu}) \\ \quad=\frac{1}{2}\|w\|^{2}+C \sum_{i=1}^{N}\left(\xi_{i}+\widehat{\xi}_{i}\right)-\sum_{i=1}^{N} \xi_{i} \mu_{i}-\sum_{i=1}^{N} \widehat{\xi}_{i} \widehat{\mu}_{i} \\ \quad+\sum_{i=1}^{N} \alpha_{i}\left(f\left(x_{i}\right)-y_{i}-\epsilon-\xi_{i}\right)+\sum_{i=1}^{N} \widehat{\alpha}_{i}\left(y_{i}-f\left(x_{i}\right)-\epsilon-\widehat{\xi}_{i}\right) \end{array} L(w,b,α,α^,ξ,ξ,μ,μ^)=21w2+Ci=1N(ξi+ξ i)i=1Nξiμii=1Nξ iμ i+i=1Nαi(f(xi)yiϵξi)+i=1Nα i(yif(xi)ϵξ i)
    ​ 再令 L ( w , b , α , α ^ , ξ , ξ , μ , μ ^ ) L(w, b, \alpha, \hat{\alpha}, \xi, \xi, \mu, \hat{\mu}) L(w,b,α,α^,ξ,ξ,μ,μ^) w , b , ξ , ξ ^ w,b,\xi,\hat{\xi} w,b,ξ,ξ^求偏导等于0,得: w = ∑ i = 1 N ( α ^ i − α i ) x i w=\sum_{i=1}^{N}\left(\widehat{\alpha}_{i}-\alpha_{i}\right) x_{i} w=i=1N(α iαi)xi

    ​ 上述过程中需满足KKT条件,即要求:
    { α i ( f ( x i ) − y i − ϵ − ξ i ) = 0 α i ^ ( y i − f ( x i ) − ϵ − ξ ^ i ) = 0 α i α ^ i = 0 , ξ i ξ ^ i = 0 ( C − α i ) ξ i = 0 , ( C − α ^ i ) ξ ^ i = 0 \left\{\begin{array}{c} \alpha_{i}\left(f\left(x_{i}\right)-y_{i}-\epsilon-\xi_{i}\right)=0 \\ \hat{\alpha_{i}}\left(y_{i}-f\left(x_{i}\right)-\epsilon-\hat{\xi}_{i}\right)=0 \\ \alpha_{i} \widehat{\alpha}_{i}=0, \xi_{i} \hat{\xi}_{i}=0 \\ \left(C-\alpha_{i}\right) \xi_{i}=0,\left(C-\widehat{\alpha}_{i}\right) \hat{\xi}_{i}=0 \end{array}\right. αi(f(xi)yiϵξi)=0αi^(yif(xi)ϵξ^i)=0αiα i=0,ξiξ^i=0(Cαi)ξi=0,(Cα i)ξ^i=0
    SVR的解形如: f ( x ) = ∑ i = 1 N ( α ^ i − α i ) x i T x + b f(x)=\sum_{i=1}^{N}\left(\widehat{\alpha}_{i}-\alpha_{i}\right) x_{i}^{T} x+b f(x)=i=1N(α iαi)xiTx+b

    sklearn实现支持向量回归模型:

    sklearn.svm.SVR():创建支持向量回归模型。

    • 参数:
      kernel:核函数,{‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’}, 默认=’rbf’。(后面会详细介绍)
      degree:多项式核函数的阶数,默认 = 3。
      C:正则化参数,默认=1.0。(后面会详细介绍)
      epsilon:SVR模型允许的不计算误差的邻域大小,默认0.1。
    from sklearn.svm import SVR
    from sklearn.preprocessing import StandardScaler     # 标准化数据
    from sklearn.pipeline import make_pipeline   # 使用管道,把预处理和模型形成一个流程
    
    reg_svr = make_pipeline(StandardScaler(), SVR(C=1.0, epsilon=0.2))
    reg_svr.fit(X, y)
    reg_svr.score(X,y)
    

    KKT和对偶理论的补充知识:

    • 约束优化问题§:


      m i n f ( x ) s . t .        g i ( x ) ≤ 0 ,    i = 1 , 2 , . . . , m            h j ( x ) = 0 ,    j = 1 , 2 , . . . , l min f(x) \\ s.t.\;\;\;g_i(x) \le 0,\; i=1,2,...,m\\ \;\;\;\;\; h_j(x) = 0,\; j=1,2,...,l minf(x)s.t.gi(x)0,i=1,2,...,mhj(x)=0,j=1,2,...,l
      我们假设 x ∗ x^* x为满足以上条件的局部最优解, p ∗ = f ( x ∗ ) p^* = f(x^*) p=f(x),我们的目的就是要找到 x ∗ x^* x p ∗ p^* p,满足不等式和等式约束的x集合成为可行域,记作S。

    • KKT条件(最优解的一阶必要条件):

      举个例子,我们考虑:( x ∗ x^* x为我们的最优解)
      m i n f ( x ) s . t .    g 1 ( x ) ≤ 0 ,    x ∈ R n        g 2 ( x ) ≤ 0        g 3 ( x ) ≤ 0 minf(x)\\ s.t.\;g_1(x) \le 0,\;x \in R^n\\ \;\;\;g_2(x) \le 0\\ \;\;\;g_3(x) \le 0 minf(x)s.t.g1(x)0,xRng2(x)0g3(x)0
      ​ 我们可以看到: − ∇ f ( x ∗ ) -\nabla f(x^*) f(x)可以由 ∇ g 1 ( x ∗ ) \nabla g_1(x^*) g1(x) ∇ g 2 ( x ∗ ) \nabla g_2(x^*) g2(x)线性表出,因此有: − ∇ f ( x ∗ ) = λ 1 ∇ g 1 ( x ∗ ) + λ 2 ∇ g 2 ( x ∗ ) -\nabla f(x^*) = \lambda_1 \nabla g_1(x^*) + \lambda_2 \nabla g_2(x^*) f(x)=λ1g1(x)+λ2g2(x),其中 λ 1 , λ 2 ≥ 0 \lambda_1,\lambda_2 \ge 0 λ1,λ20,即:
      ∇ f ( x ∗ ) + λ 1 ∇ g 1 ( x ∗ ) + λ 2 ∇ g 2 ( x ∗ ) = 0 ,        其 中 λ 1 , λ 2 ≥ 0 \nabla f(x^*) + \lambda_1 \nabla g_1(x^*) + \lambda_2 \nabla g_2(x^*) = 0,\;\;\;其中\lambda_1,\lambda_2 \ge 0 f(x)+λ1g1(x)+λ2g2(x)=0,λ1,λ20
      ​ 我们把没有起作用的约束 g 3 ( x ) g_3(x) g3(x)也放到式子里面去,目的也就是为了书写方便,即要求:
      ∇ f ( x ∗ ) + λ 1 ∇ g 1 ( x ∗ ) + λ 2 ∇ g 2 ( x ∗ ) + λ 3 ∇ g 3 ( x ∗ ) = 0 ,        其 中 λ 1 , λ 2 ≥ 0 , λ 3 = 0 \nabla f(x^*) + \lambda_1 \nabla g_1(x^*) + \lambda_2 \nabla g_2(x^*) + \lambda_3 \nabla g_3(x^*)= 0,\;\;\;其中\lambda_1,\lambda_2 \ge 0,\lambda_3 = 0 f(x)+λ1g1(x)+λ2g2(x)+λ3g3(x)=0,λ1,λ20,λ3=0
      ​ 由于点 x ∗ x^* x位于方程 g 1 ( x ) = 0 g_1(x)=0 g1(x)=0 g 2 ( x ) = 0 g_2(x)=0 g2(x)=0上,因此: λ 1 g 1 ( x ∗ ) = 0 , λ 2 g 2 ( x ∗ ) = 0 , λ 3 g 3 ( x ∗ ) = 0 \lambda_1 g_1(x^*)= 0,\lambda_2 g_2(x^*) = 0 , \lambda_3 g_3(x^*)= 0 λ1g1(x)=0,λ2g2(x)=0,λ3g3(x)=0

    • 因此,KKT条件就是:假设 x ∗ x^* x为最优化问题§的局部最优解,且 x ∗ x^* x 在某个适当的条件下,有:

    ∇ f ( x ∗ ) + ∑ i = 1 m λ i ∇ g ( x ∗ ) + ∑ j = 1 l μ j ∇ h j ( x ∗ ) = 0 ( 对 偶 条 件 ) λ i ≥ 0 ,    i = 1 , 2 , . . . , m ( 对 偶 条 件 ) g i ( x ∗ ) ≤ 0 ( 原 问 题 条 件 ) h j ( x ∗ ) = 0 ( 原 问 题 条 件 ) λ i g ( x ∗ ) = 0 ( 互 补 松 弛 定 理 ) \nabla f(x^*) + \sum\limits_{i=1}^{m}\lambda_i \nabla g(x^*) + \sum\limits_{j=1}^{l}\mu_j \nabla h_j(x^*) = 0(对偶条件)\\ \lambda_i \ge 0,\;i = 1,2,...,m(对偶条件)\\ g_i(x^*) \le 0(原问题条件)\\ h_j(x^*) = 0(原问题条件)\\ \lambda_i g(x^*) = 0(互补松弛定理) f(x)+i=1mλig(x)+j=1lμjhj(x)=0()λi0,i=1,2,...,m()gi(x)0()hj(x)=0()λig(x)=0()

    • 对偶理论:
      为什么要引入对偶问题呢?是因为原问题与对偶问题就像是一个问题两个角度去看,如利润最大与成本最低等。有时侯原问题上难以解决,但是在对偶问题上就会变得很简单。再者,任何一个原问题在变成对偶问题后都会变成一个凸优化的问题,这点我们后面会有介绍。下面我们来引入对偶问题:
      首先,我们的原问题§是:
      m i n f ( x ) s . t .        g i ( x ) ≤ 0 ,    i = 1 , 2 , . . . , m            h j ( x ) = 0 ,    j = 1 , 2 , . . . , l min f(x) \\ s.t.\;\;\;g_i(x) \le 0,\; i=1,2,...,m\\ \;\;\;\;\; h_j(x) = 0,\; j=1,2,...,l minf(x)s.t.gi(x)0,i=1,2,...,mhj(x)=0,j=1,2,...,l
      引入拉格朗日函数: L ( x , λ , μ ) = f ( x ) + ∑ i = 1 m λ i g i ( x ) + ∑ j = 1 l μ j h j ( x ) L(x,\lambda,\mu) = f(x) + \sum\limits_{i=1}^{m}\lambda_i g_i(x) + \sum\limits_{j=1}^{l}\mu_j h_j(x) L(x,λ,μ)=f(x)+i=1mλigi(x)+j=1lμjhj(x)
      拉格朗日对偶函数:
      d ( λ , μ ) = m i n x ∈ X { f ( x ) + ∑ i = 1 m λ i g i ( x ) + ∑ j = 1 l μ j h j ( x ) } , 其 中 X 为 满 足 条 件 的 x 变 量 ≤ m i n x ∈ S { f ( x ) + ∑ i = 1 m λ i g i ( x ) + ∑ j = 1 l μ j h j ( x ) } , 由 于 g i ( x ) ≤ 0 , h j ( x ) = 0 , λ i ≥ 0 , 其 中 S 为 可 行 域 ≤ m i n x ∈ S { f ( x ) } d(\lambda,\mu) = min_{x\in X}\{ f(x) + \sum\limits_{i=1}^{m}\lambda_i g_i(x) + \sum\limits_{j=1}^{l}\mu_j h_j(x)\} ,其中X为满足条件的x变量\\ \le min_{x\in S}\{ f(x) + \sum\limits_{i=1}^{m}\lambda_i g_i(x) + \sum\limits_{j=1}^{l}\mu_j h_j(x) \},由于g_i(x) \le 0,h_j(x) = 0,\lambda_i \ge 0 ,其中S为可行域\\ \le min_{x\in S}\{f(x) \} d(λ,μ)=minxX{f(x)+i=1mλigi(x)+j=1lμjhj(x)},XxminxS{f(x)+i=1mλigi(x)+j=1lμjhj(x)},gi(x)0,hj(x)=0,λi0,SminxS{f(x)}
      因此:拉格朗日对偶函数 d ( λ , μ ) d(\lambda,\mu) d(λ,μ)是原问题最优解的函数值 p ∗ p^* p的下界,即每个不同的 λ \lambda λ μ \mu μ确定的 d ( λ , μ ) d(\lambda,\mu) d(λ,μ)都是 p ∗ p^* p的下界,但是我们希望下界越大越好,因为越大就更能接近真实的 p ∗ p^* p。因此: 拉格朗日对偶问题(D)转化为:
      m a x λ , μ d ( λ , μ ) s . t . λ i ≥ 0 , i = 1 , 2 , . . . , m 也 就 是 : m a x λ ≥ 0 , μ    m i n x ∈ S L ( x , λ , μ ) max_{\lambda,\mu}d(\lambda,\mu)\\ s.t. \lambda_i \ge 0,i = 1,2,...,m\\ 也就是:\\ max_{\lambda \ge 0,\mu}\;min_{x \in S} L(x,\lambda,\mu) maxλ,μd(λ,μ)s.t.λi0,i=1,2,...,mmaxλ0,μminxSL(x,λ,μ)
      我们可以观察到,对偶问题是关于 λ \lambda λ μ \mu μ的线性函数,因此对偶问题是一个凸优化问题,凸优化问题在最优化理论较为简单。
      弱对偶定理:对偶问题(D)的最优解 D ∗ D^* D一定小于原问题最优解 P ∗ P^* P,这点在刚刚的讨论得到了充分的证明,一定成立。
      强对偶定理:对偶问题(D)的最优解 D ∗ D^* D在一定的条件下等于原问题最优解 P ∗ P^* P,条件非常多样化且不是唯一的,也就是说这是个开放性的问题,在这里我给出一个最简单的条件,即: f ( x ) f(x) f(x) g i ( x ) g_i(x) gi(x)为凸函数, h j ( x ) h_j(x) hj(x)为线性函数,X是凸集, x ∗ x^* x满足KKT条件,那么 D ∗ = P ∗ D^* = P^* D=P
    展开全文
  • 一元线性回归只能拟合y=ax+by=ax+by=ax+b,或者说只能拟合直线。 其实对于多元线性回归来说,x2,x3...x_2,x_3...x2​,x3​...是不同于x1=xx_1=xx1​=x的另一个特征,方程可表示为: y=θ1x1+θ2x2+...+θnxn+θ0y=\...

    1 概述

    一元线性回归只能拟合 y = a x + b y=ax+b y=ax+b,或者说只能拟合直线。
    其实对于多元线性回归来说, x 2 , x 3 . . . x_2,x_3... x2,x3...是不同于 x 1 = x x_1=x x1=x的另一个特征,方程可表示为:
    y = θ 1 x 1 + θ 2 x 2 + . . . + θ n x n + θ 0 y=\theta _{1}x_1+\theta _{2}x_2+...+\theta _{n}x_n+\theta _{0} y=θ1x1+θ2x2+...+θnxn+θ0
    x 1 , x 2 . . . x_1,x_2... x1,x2...是因变量(特征), θ 1 , θ 2 . . . \theta _{1},\theta _{2}... θ1,θ2...是系数, θ 0 \theta _{0} θ0是截距。
    多元线性回归可以用特征方程去求解。
    在这里插入图片描述

    代码实现:

    import numpy as np
    
    class LinearRegression():
        def __init__(self):
            self._theta = None
            self.coef = None
            self.interception = None
    
        def fit(self, X_train, y_train):
            X_b = np.hstack([np.ones((X_train.shape[0] ,1)), X_train])
    
            self._theta = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y_train)
    
            self.coef = self._theta[1:]
    
            self.interception = self._theta[0]
            
            return self
    
        def predict(self, X_test):
            X_b = np.hstack([np.ones((X_test.shape[0] ,1)), X_test])
            return X_b.dot(self._theta)
    

    2 多项式线性回归

    多项式线性回归是多元线性回归中比较特殊的一类,只有一个因变量 x x x,其它的特征是 x x x的几次方,比如 y = a x 2 + b x + c y=ax^2+bx+c y=ax2+bx+c或者是更高次数的方程:
    y = θ 1 x + θ 2 x 2 + . . . + θ n x n + θ 0 y=\theta _{1}x+\theta _{2}x^2+...+\theta _{n}x^n+\theta _{0} y=θ1x+θ2x2+...+θnxn+θ0

    y = a x 2 + b x + c y=ax^2+bx+c y=ax2+bx+c为例:

    import numpy as np
    from matplotlib import pyplot as plt
    
    x = np.random.uniform(-3, 3, size=100)
    x = np.sort(x)
    X = x.reshape(-1, 1)
    # X.shape (100, 1)
    
    y = 0.5*x**2 + x + 2 + np.random.normal(0, 1, 100)
    # y.shape (100,)
    
    plt.scatter(X, y)
    

    在这里插入图片描述
    这是一个抛物线,如果再用一元线性回归去拟合,就是下面的样子,可以发现误差时非常大的:
    在这里插入图片描述
    一元线性回归只有一个特征 x x x,多项式回归则是添加新的特征( x 2 , x 3 . . . x^2, x^3... x2,x3...),这里我只需要添加 x x x的平方,来拟合一个抛物线。

    3.1 使用np.hstack函数

    # 使用np.hstack函数,将两个特征在水平方向上拼接
    X2 = np.hstack([X, X**2]) # 拼接
    # X2.shape (100, 2)
    
    '''
    注:  np.vstack() :在竖直方向上堆叠
    	 np.hstack() :在水平方向上拼接
    '''
    
    from sklearn.linear_model import LinearRegression
    lin_reg = LinearRegression()
    lin_reg.fit(X2, y)
    y_predict = lin_reg.predict(X2)
    print(lin_reg.coef_) # 系数 a, b
    # array([1.04078131, 0.54484198])
    print(lin_reg.intercept_) # 截距 c
    # 1.9212545662064286
    
    # 绘制一下图像
    plt.scatter(X, y, color="b")
    plt.plot(x, y_predict, color="r")
    

    在这里插入图片描述

    3.2 PolynomialFeatures

    from sklearn.preprocessing import PolynomialFeatures
    
    # 构造多项式,如果只有一个x,degree=2,则为[1, x, x^2],其中1代表截距列
    poly = PolynomialFeatures(degree=2)
    
    poly.fit(X)
    
    X3 = poly.transform(X) # 构建X
    X3.shape  # (100,3)
    
    

    同样的,用LinearRegression()拟合。

    lin_reg = LinearRegression()
    lin_reg.fit(X3, y)
    y_predict = lin_reg.predict(X3)
    

    3.3 pipeline

    
    from sklearn.pipeline import  Pipeline
    from sklearn.preprocessing import StandardScaler
    
    # 三合一
    poly_reg = Pipeline([
    	("ploy", PolynomialFeatures(degree=2)), # 生成多项式特征
    	("std_scaler", StandardScaler()),       # 数据归一化
    	("lin_reg", LinearRegression())         # 进行线性回归
    ])
    
    poly_reg.fit(X, y)
    y_predict = poly_reg.predict(X)
    
    plt.scatter(X, y, color="b")
    plt.plot(x, y_predict, color="r")
    

    在这里插入图片描述

    展开全文
  • 我们可以使用线性回归模型来拟合数据,然而,在现实中,数据未必总是线性(或接近线性)的。当数据并非线性时,直接使用LinearRegression的效果可能会较差,产生欠拟合。 import numpy as np import matplotlib as...

    1. 尝试线性回归模型解决欠拟合(with codes)

    • 尝试用线性回归模型,来解决欠拟合问题,效果不好
      我们可以使用线性回归模型来拟合数据,然而,在现实中,数据未必总是线性(或接近线性)的。当数据并非线性时,直接使用LinearRegression的效果可能会较差,产生欠拟合。
    import numpy as np
    import matplotlib as mpl
    import matplotlib.pyplot as plt
    from sklearn.linear_model import LinearRegression
    
    mpl.rcParams["font.family"] = "SimHei"
    mpl.rcParams["axes.unicode_minus"] = False
    
    x = np.linspace(0, 10, 50)
    # 真实的数据分布。该分布是非线性的。
    y = x * np.sin(x)
    # np.newaxis 表示进行维度的扩展,可以认为是增加一个维度,该维度为1。
    # 此种方式也可以通过reshape方法来实现。
    X = x[:, np.newaxis]
    lr = LinearRegression()
    lr.fit(X, y)
    # 输出在训练集上的分值。查看线性回归LinearRegression在非线性数据集上的拟合效果。
    print(lr.score(X, y))
    # 将样本数据以散点图进行绘制。
    plt.scatter(x, y, c="g", label="样本数据")
    # 绘制预测值(模型的回归线)
    plt.plot(X, lr.predict(X), "r-", label="拟合线")
    plt.legend()
    plt.show()
    # 结果:R ^ 2值为0.05908132146396671,模型在训练集上表现非常不好,产生欠拟合。
    

    在这里插入图片描述

    程序解释

    是真实线,还没有加噪声。就是想看,非线性再线性上表现怎么样。
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述
    表示要进行维度的扩展
    可以认为是增加一个维度,该维度为1
    Why要增加一个维度?
    意味着x能否送到fit?不能
    一维不能
    在这里插入图片描述
    X要变成二维
    现在是 50,
    变成50,1
    之前是reshape
    现在变成
    在这里插入图片描述

    # x = np.linspace(0, 10, 50)
    # print(x.shape)
    # print(x[:, np.newaxis].shape)
    

    在这里插入图片描述

    习惯大写
    在这里插入图片描述
    欠拟合 是不涉及未知数据的,欠拟合是训练集相关
    跟未知数据无关

    Eg. 模拟题都做不好

    看下效果
    在这里插入图片描述
    将样本数据以散点图进行绘制

    真实值
    在这里插入图片描述
    还差一个预测值,就是一条回归线,模型的回归线。
    在这里插入图片描述
    Show()在jupyter里面可以不加,pycharm里面得加,这也是 sinx x

    综上看,这个拟合效果不好。所以线性回归 对非线性 拟合效果不好。相当于蒙。

    因为线性回归是直的,在训练集上表现不好,产生欠拟合现象, R 2 R^{2} R2 值很低。

    2. 欠拟合怎么办?引入多项式扩展

    此时,我们可以尝试使用多项式扩展来进行改进。
    多项式扩展,可以认为是对现有数据进行的一种转换,通过将数据映射到更高维度的空间中,该模型就可以拟合更广泛的数据。
    假设,我们有如下的二元线性模型:

    y ^ = w 0 + w 1 x 1 + w 2 x 2 \hat{y} = w_{0} + w_{1}x_{1} + w_{2}x_{2} y^=w0+w1x1+w2x2

    如果该模型的拟合效果不佳,我们就可以对该模型进行多项式扩展。例如,我们进行二项式扩展(也可以进行更高阶的扩展),结果为:

    y ^ = w 0 + w 1 x 1 + w 2 x 2 + w 3 x 1 x 2 + w 4 x 1 2 + w 5 x 2 2 \hat{y} = w_0 + w_1 x_1 + w_2 x_2 + w_3 x_1 x_2 + w_4 x_1^2 + w_5 x_2^2 y^=w0+w1x1+w2x2+w3x1x2+w4x12+w5x22

    当进行多项式扩展后,我们就可以认为,模型由以前的直线变成了曲线。从而可以更灵活的去拟合数据。

    3 多项式拟合的应用,仍然变为线性模型

    经过多项式扩展后,我们依然可以使用之前的线性回归模型去拟合数据。这是因为,我们可以假设:
    z = [ x 1 , x 2 , x 1 x 2 , x 1 2 , x 2 2 ] z = [x_1, x_2, x_1 x_2, x_1^2, x_2^2] z=[x1,x2,x1x2,x12,x22]

    这样,之前的模型就会变成:
    y ^ = w 0 + w 1 z 1 + w 2 z 2 + w 3 z 3 + w 4 z 4 + w 5 z 5 \hat{y} = w_0 + w_1 z_1 + w_2 z_2 + w_3 z_3 + w_4 z_4 + w_5 z_5 y^=w0+w1z1+w2z2+w3z3+w4z4+w5z5
    从而,我们依然可以认为,这还是一种线性模型

    线性回归本身解决不了,可以多项式扩展
    多元线性回归 是直的 是一个面
    在这里插入图片描述

    怎么进行多项式扩展?扩展到几阶?
    回顾什么是线性回归模型?

    1. 图像是直的
    2. 特征的最高次项是1
      先进行直接的多项式扩展:

    在这里插入图片描述
    二维变为五维,在空间中张开了,想象…

    一维 线
    二维 平面
    三维 超平面

    多项式扩展,把它由一维的线变为面,再变为超平面。

    扩展是怎么来的?扩展到几阶?
    所有的特征任意组合:

    在这里插入图片描述

    w是几不重要,b就是w

    4. 多项式转换规则 PolynomialFeatures

    我们可以使用sklearn中提供的PolynomialFeatures类来实现多项式扩展。通过powers_属性可以获取扩展之后每个输入特征的指数矩阵。指数矩阵的形状为[输出特征数, 输入特征数]。powers_[i, j]表示第i个输出特征中,第j个输入特征的指数值。

    例如,如果输入样本的特征数为2,多项式扩展阶数为2,则指数矩阵为:
    p o w e r s = [ 0 0 1 0 0 1 2 0 1 1 0 2 ] powers_ = \begin{bmatrix} 0 & 0\\ 1 & 0\\ 0 & 1\\ 2 & 0\\ 1 & 1\\ 0 & 2 \end{bmatrix} powers=010210001012

    多项式转换,其实就是将输入特征转换成输出特征。矩阵的每行对应每个输出特征,每列对应每个输入特征的指数,例如,对于两个输入特征 x 1 与 x 2 x_1与x_2 x1x2来讲,多项式转换之后的值为:

    [ x 1 0 x 2 0 ,   x 1 1 x 2 0 ,   x 1 0 x 2 1 ,   x 1 2 x 2 0 ,   x 1 1 x 2 1 ,   x 1 0 x 2 2 ] [x_1^0x_2^0,\ x_1^1x_2^0,\ x_1^0x_2^1,\ x_1^2x_2^0,\ x_1^1x_2^1,\ x_1^0x_2^2] [x10x20, x11x20, x10x21, x12x20, x11x21, x10x22]

    即:

    [ 1 ,   x 1 ,   x 2 ,   x 1 2 ,   x 1 x 2 ,   x 2 2 ] [1,\ x_1,\ x_2,\ x_1^2,\ x_1 x_2,\ x_2^2] [1, x1, x2, x12, x1x2, x22]

    以前的非线性回归,还能适用吗?将Z1 = x1 … Z5,带入上面的公式。如下图:
    在这里插入图片描述
    y_hat又变成线性模型了,之前的线性回归模型,对多项式扩展之后的方程同样能够适用。
    尽管是最高次项,只要经过转换,仍然能够进行适用。
    可以假设,所以可以用linearregresstion处理多项式。
    以前2个特征,现在是5个特征的超平面,拟合能力更强。

    多项式特征,这样一个类 ,可以实现一个多项式扩展,在以前的特征上转换。
    从低维的空间映射到高维的空间。

    拟合之后,有powers属性,下划线。得到一个矩阵,输出的特征的数量。以及每一个输入特征的,扩展的时候没有必要自己去数,如何扩展咱么得知道细节是如何扩展。

    Powers 扩展后 每一个特征的 指数;Power_可以看成二维数组
    形状。
    每一个输入特征都会带指数;每一列 特征的指数值。
    在这里插入图片描述
    输入特征: 转换之前的特征数,因为我们现在要实现多项式转换。
    在这里插入图片描述
    在这里插入图片描述
    其实转换规则就是:多项式扩展
    以前 2个特征 现在扩展到5个特征 不考虑截距
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    化简 第一个是1

    二维 输入特征 变成 五维输出特征
    在这里插入图片描述

    5. 多项式扩展的规则(with codes)

    每个输入特征分别带有一个指数(指数值为非负整数),然后让指数之间进行任意可能的组合,但要保证所有的指数之和不能大于扩展的阶数。

    
    # 类似PolynomialFeatures这样功能的类(数据预处理),所有的转换方法都叫做transform。
    # 拟合与转换可以同时进行,方法名称都叫做fit_transform。
    
    import numpy as np
    # sklearn.preprocessing 该模块提供数据预处理的相关功能。
    # PolynomialFeatures多项式扩展类,可以对模型进行n阶扩展。从而可以解决欠拟合问题。
    from sklearn.preprocessing import PolynomialFeatures
    
    X = np.array([[1, 2], [3, 4]])
    # X = np.array([[1, 2, 3], [3, 4, 5]])
    # 定义多项式扩展类,参数指定要扩展的阶数。
    poly = PolynomialFeatures(2)
    # 拟合模型,计算power_的值。
    # poly.fit(X)
    # 对数据集X进行多项式扩展,即进行多项式转换。
    # r = poly.transform(X)
    # 我们可以令fit与transofrm两步一起完成。
    r = poly.fit_transform(X)
    
    print("转换之后的结果:")
    print(r)
    print("指数矩阵:")
    # 指数矩阵,形状为(输出特征数,输入特征数)。
    print(poly.powers_)
    print(f"输入的特征数量:{poly.n_input_features_}")
    print(f"输出的特征数量:{poly.n_output_features_}")
    
    # 根据power_矩阵,自行计算转换结果。
    # 循环获取X中的每一个样本。
    for x1, x2 in X:
        for e1, e2 in poly.powers_:
            print(x1 ** e1 * x2 ** e2, end="\t")
        print()
    

    在这里插入图片描述

    程序解释

    新的 模块 sklern.preprocessing 数据预处理的模块
    多项式扩展 相当于 数据转换 相当于 数据预处理
    Metics类: 提供 模型评估 的类
    多项式扩展类

    2行2列 1,2是一个样本
    1 x1 2 x2
    一列是一个特征
    在这里插入图片描述
    定义了一个多项式对象
    不要用predict, 这个模型不是负责预测的 Poly
    把转换的结果交给别的模型进行预测

    只有x没有y
    拟合 是干什么 试求powers
    扩展的阶数不同 powers数量不一样
    Fit就是根据传递额阶数 计算powers的值
    在这里插入图片描述
    有两个样本
    转换成两个
    根据
    在这里插入图片描述

    在这里插入图片描述
    指数矩阵就是 形状为
    在这里插入图片描述
    在这里插入图片描述
    换成3阶
    在这里插入图片描述
    优化:
    合二为一
    在这里插入图片描述
    poly.fit(X)
    r = poly.fit_transform(X)

    再来,根据power矩阵,自行计算转换结果

    拆包
    X1 x2

    对powers矩阵循环
    在这里插入图片描述
    e1次幂,还是指数后,乘积,只不过使用循环
    结合性,乘方有优先性
    通用上的预处理规则,Fit就是计算转换的规则
    没有powers数组,是转换不了的;而这个数组,是通过数组拟合出来的

    多项式如何进行转换?
    扩展就是多项式转换?

    6. 应用多项式扩展解决欠拟合问题(with codes)

    对之前未解决的欠拟合问题,应用多项式扩展来解决
    现在,就让我们对之前的程序来进行多项式扩展,尝试解决欠拟合问题。

    import numpy as np
    import matplotlib as mpl
    import matplotlib.pyplot as plt
    from sklearn.linear_model import LinearRegression
    from sklearn.preprocessing import PolynomialFeatures
    
    mpl.rcParams["font.family"] = "SimHei"
    mpl.rcParams["axes.unicode_minus"] = False
    
    x = np.linspace(0, 10, 50)
    y = x * np.sin(x)
    X = x[:, np.newaxis]
    figure, ax = plt.subplots(2, 3)
    figure.set_size_inches(18, 10)
    ax = ax.ravel()
    
    # n为要进行多项式扩展的阶数。
    for n in range(1, 7):
        # 注意:多项式1阶扩展,相当于没有扩展(没有变化)。
        poly = PolynomialFeatures(degree=n)
        X_transform = poly.fit_transform(X)
        # 注意:多项式扩展之后,我们依然可以将数据视为线性的,因此,我们还是可以通过之前的
        # LinearRegression来求解问题。
        lr = LinearRegression()
        # 使用多项式扩展之后的数据集来训练模型。
        lr.fit(X_transform, y)
        ax[n - 1].set_title(f"{n}阶,拟合度:{lr.score(X_transform, y):.3f}")
        ax[n - 1].scatter(x, y, c="g", label="样本数据")
        ax[n - 1].plot(x, lr.predict(X_transform), "r-", label="拟合线")
        ax[n - 1].legend()
    

    在这里插入图片描述
    在这里插入图片描述

    程序解释

    生成数据集 50个点
    创建y 非线性
    把x变成二维的,使用np.newaxis
    50,
    50,1

    接下来进行可视化的绘图操作
    看一下多项式扩展的效果好不好
    R^2值怎么样
    数据如何进行的分布,线靠的近不近

    阶数很关键,画6个子图 每个阶数的拟合情况
    每一个阶的r^2
    Subplots子绘图区域
    画布大小 figure.set 因为2 3 宽
    Ravel() 变成一层循环,之前是二维
    N表示要扩展的阶数
    在这里插入图片描述
    在这里插入图片描述
    N=1 1阶 数组是0开始 所以n-1
    标题
    拟合度 score求解
    把x_transform放进去
    把样本数据画一下,看拟合情况
    散点画完了,画预测线, x传进来,需要有一个对应的y值

    特征多了,也就是复杂度越来越多

    通过多项式扩展 解决了欠拟合的问题

    Why能这么做?
    输入的时候特征比较少,所以咱么就给它映射到更高维的空间(超平面)
    咱们拟合的能力就会变强

    维度越高,越能捕获更多的数据
    二维图来看,线的弯曲程度越高

    7. 引入流水线方法(with codes)

    在上例中,我们使用多项式对训练数据进行了转换(扩展),然后使用线性回归类(LinearRegression)在转换后的数据上进行拟合
    可以说,这是两个步骤。我们虽然可以分别去执行这两个步骤,然而,当数据预处理的工作较多时,可能会涉及更多的步骤(例如标准化,编码等),此时再去一一执行会显得过于繁琐。

    流水线(Pipeline类)可以将每个评估器视为一个步骤,然后将多个步骤作为一个整体而依次执行,这样,我们就无需分别执行每个步骤。流水线中的所有评估器(除了最后一个评估器外)都必须具有转换功能(具有transform方法)。

    流水线具有最后一个评估器的所有方法。当调用某个方法f时,会首先对前n - 1个(假设流水线具有n个评估器)评估器执行transform方法(如果调用的f是fit方法,则n-1个评估器会执行fit_transform方法),对数据进行转换,然后在最后一个评估器上调用f方法。

    例如,当在流水线上调用fit方法时,将会依次在每个评估器上调用fit方法,然后再调用transform方法,接下来将转换之后的结果传递给下一个评估器,直到最后一个评估器调用fit方法为止(最后一个评估器不会调用transform方法)。而当在流水线上调用predict方法时,则会依次在每个评估器上调用transform方法,最后在最后一个评估器上调用predict方法。

    import numpy as np
    import matplotlib as mpl
    import matplotlib.pyplot as plt
    from sklearn.linear_model import LinearRegression
    from sklearn.preprocessing import PolynomialFeatures
    # sklearn库提供的流水线类,作用就是将多个评估器打包成一个整体,这样,当我们对流水线进行某些操作时,
    # 流水线内的所有评估器都会执行相关的操作。这样,就可以作为一个整体而执行,无需我们分别对每个评估器
    # 单独进行执行。
    from sklearn.pipeline import Pipeline
    
    mpl.rcParams["font.family"] = "SimHei"
    mpl.rcParams["axes.unicode_minus"] = False
    
    x = np.linspace(0, 10, 50)
    y = x * np.sin(x)
    X = x[:, np.newaxis]
    # 定义流水线中的每一个评估器。
    # 格式为一个含有元组的列表。每个元组定义流水线中的一个步骤。
    # 元组中含有两个元素。前面的元素为流水线步骤的名称,后面的
    # 元素为该流水线步骤处理的对象。
    estimators = [("poly", PolynomialFeatures()), ("lr", LinearRegression())]
    # 创建流水线对象,将评估器数组传递给流水线类。
    pipeline = Pipeline(estimators)
    # 流水线的steps属性,可以返回流水线所有的步骤。包括步骤名与该步骤的处理对象。
    # pipeline.steps
    # 流水线的named_steps属性,与steps属性相似,只是类型不同(字典类型)。
    # pipeline.named_steps
    # 设置流水线对象的参数信息。
    # 如果需要为流水线的某个步骤处理对象设置相关的参数,则参数名为:步骤名__处理对象参数。
    pipeline.set_params(poly__degree=8)
    # 获取流水线支持设置的所有参数。
    # print(pipeline.get_params())
    
    # 在流水线对象上调用fit方法,相当于对除了最后一个评估器之外的所有评估器调用fit_transform方法,
    # 然后最后一个评估器调用fit方法。
    pipeline.fit(X, y)
    # 流水线对象具有最后一个评估器的所有方法。
    # 当通过流水线对象,调用最后一个评估器的方法时,会首先调用之前所有评估器的transform方法。
    score = pipeline.score(X, y)
    plt.title(f"8阶,拟合度:{score:.3f}")
    plt.scatter(X, y, c="g", label="样本数据")
    # 当调用流水线对象的predict方法时,除最后一个评估器外,其余评估器会调用transform方法,然后,最后
    # 一个评估器调用predict方法。
    plt.plot(X, pipeline.predict(X), "r-", label="拟合线")
    

    在这里插入图片描述

    程序解释

    第一步:
    使用多项式进行扩展。

    第二步:
    使用线性回归类,对多项式扩展之后的结果,进行训练,
    预测结果。

    但是再实际的机器学习过程中,可能更复杂
    数据预处理,很多步骤
    流水线 封罐头 很多步 都能作为一个整体进行操作

    在这里插入图片描述

    这个操作太繁琐
    直接打包进 流水线,然后流水线调用fit就行了,流水线除了最后一个调用fit其他都会调用fit transform

    最后是predict,不是fit
    哪怕不是进行流水线,我们永远都是在训练集上进行fit,
    我们现在调用predict的,实在测试集上,不要再训练集上fit

    测试

    在这里插入图片描述

    看一下流水线的程序
    之前是分成2步的,现在我们分成一步实现
    新库
    在这里插入图片描述

    执行什么操作呢?
    定义流水线 里面的 每一个评估器
    是一个含有元组的列表
    后面是评估期的对象
    名字 步骤要处理的对象
    创建流水线对象 把相关评估器数组 传递给流水线内

    步骤
    在这里插入图片描述

    名字 对象 顺便把默认的参数也显示出来
    单独的想看流水线的处理对象,用这种 字典的方法
    在这里插入图片描述

    每个步骤有了,获得相关步骤就很简单
    在这里插入图片描述

    在这里插入图片描述

    两部一起完成了
    在这里插入图片描述

    在这里插入图片描述

    之前是 转换之后的
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    流水线的类 pipeline 很有用,放到一起,统一执行。
    优势:
    1.放到一起
    2. 可以设置参数

    展开全文
  • 使用python语言实现机器学习多项式线性回归 数据是用的吴恩达教授机器学习里的ex1data1.txt import matplotlib.pyplot as plt import numpy as np from sklearn import linear_model from sklearn.preprocessing ...
  • import numpy as np import matplotlib.pyplot as plt from sklearn import datasets boston = datasets.load_boston() x = boston.data y = boston.target from sklearn.model_selection import train_test_split...
  • 对于线性关系,我们可以进行简单的线性回归。对于其他关系,我们可以尝试拟合一条曲线。曲线拟合是构建一条曲线或数学函数的过程,它对一系列数据点具有最佳的拟合效果。使用示例数据集#我们将使Y成为因变量,X成为...
  • #非线性回归模型 setwd("I:/研一课程/2.2回归分析/R/data")#设定当前的工作目录,重要! a a.nls a.sum a.sum #(1)采用龚珀兹模型形式,建立非线性模型 SST Rsquare Rsquare #多项式回归 setwd("I:/...
  • 本文介绍回归模型的原理知识,包括线性回归多项式回归和逻辑回归,并详细介绍Python Sklearn机器学习库的LinearRegression和LogisticRegression算法及回归分析实例。进入基础文章,希望对您有所帮助。
  • 多项式回归 """ def make_features(x): """Builds features a matrix with columns [x,x^2,x^3]""" x = x.unsqueeze(1) return torch.cat([x ** i for i in range...
  • 3) 进行非线性回归。在此示例中,这三个中的每一个都将找到基本相同的最佳拟合曲线。 多项式回归 多项式回归实际上只是多元回归的一种特殊情况。 对于线性模型(lm),调整后的R平方包含在summary(model)...
  • 对于线性关系,我们可以进行简单的线性回归。对于其他关系,我们可以尝试拟合一条曲线。 曲线拟合是构建一条曲线或数学函数的过程,它对一系列数据点具有最佳的拟合效果。 使用示例数据集 #我们将使Y成为因...
  • 1.1.16.多项式回归:基函数拓展线性回归模型机器学习中一种常见模式是使用线性模型去训练非线性模型。这种方式保持了常见线性方法的快速性,同时适用于更广泛的数据。例如,一个简单的线性回归可以通过系数拓展到...
  • 什么是多项式回归 多项式回归思路与多元线性回归相似,只是为原来的数据样本添加新的特征,而新的特征是原有特征的多项式组合。 scikit-learn中的多项式回归与pipeline ...
  • 线性回归获取回归方程,并用预测结果对比实际情况,得到    红色直线是通过回归方程得到的所有样本预测值连成的直线,可以看出,一次项式的回归曲线不能很好的完成预测。此时在X样本集中添加X^2作为另一个特征,...
  • 学习率, 反应了梯度下降更新参数w的快慢, 学习率越大学习的越快, 但是可能导致模型不收敛, 学习率越小学习的越慢. gradient_descent: boolean 是否使用梯度下降方法求解参数w,如果gradient_descent=True, 则...
  • 对比利用多项式定义进行多项式拟合:笔记代码:多项式拟合和极值点连接 线性回归 sklearn.linear_model.LinearRegression() --&... return:线性回归线性回归器.fit(输入... 线性回归器.predict(输入...
  • 一般线性模型和线性回归模型Interpretability is one of the biggest challenges in machine learning. A model has more interpretability than another one if its decisions are easier for a human to ...
  • 多项式回归模型是线性回归模型的一种,此时回归函数关于回归系数是线性的。 多项式回归的最大优点就是可以通过增加x的高次项对实测点进行逼近,直至满意为止。事实上,多项式回归可以处理相当一类非线性问题,它在...
  • 对于一般的线性回归模型,由于该函数拟合出来的是一条直线,所以精度欠佳,我们可以考虑多项式回归来拟合更多的模型。所谓多项式回归,其本质也是线性回归。也就是说,我们采取的方法是,提高每个属性的次数来增加...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,105
精华内容 7,642
关键字:

多项式线性回归模型