精华内容
下载资源
问答
  • 主要介绍了Python多项式回归的实现方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 多项式回归案例代码

    2019-02-10 20:29:03
    本案例使用房价预测的数据,使用Python做了线性回归、二次回归和三次回归,并分别得出三者的模型拟合得分,来探究针对本案例的模型拟合效果。也侧面分析了欠拟合、过拟合的现象。
  • 具体博客可参考https://blog.csdn.net/qq_32478489/article/details/82495446
  • 主要介绍了详解Pytorch 使用Pytorch拟合多项式(多项式回归),小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • sklearn实现多元线性回归及多项式回归,个人学习笔记,简单易懂,实现多项式回归
  • 机器学习是一门多领域交叉学科,涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为,以获取新的知识或技能,重新组织已有的知识结构使之不断改善自身的...
  • 对多维数据执行多元多项式回归。 拟合仅限于具有较小修改选项的标准多项式基。 随意实施术语归约启发式。 该功能在 m.file 中有希望足够详细的解释。 随意发表评论或查询。 不再需要任何额外的工具箱! 前往...
  • matlab开发-多项式回归法。用最小二乘法实现多项式回归方法。
  • 主要介绍了scikit-learn线性回归,多元回归,多项式回归的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 目前,您有兴趣拟合标准多项式基础,而无需进一步干预这些条款。 内容 如何使用输入 清楚的 load Example.mat reg=MultiPolyRegress(X,Y,2) % Gives you your fit. reg = FitParameters: '-----------------' ...
  • 4,pandas用法(多项式回归实例❌).ipynb
  • 该文件是配合梯度下降法实现多项式回归,在使用时需要放在代码的同一目录下
  • 多项式回归:使用p5.js和TensorFlow.js的简单多项式回归
  • 此代码实现一维多项式回归方法。 它使用最小二乘法来寻找回归多项式系数。 脚本的输出是多项式回归系数、残差、误差平方和、确定指数以及回归模型和输入数据的图形比较。
  • 多项式回归 该笔记本使用python和sklearn -library对随机创建的数据实施多项式回归
  • 多项式回归

    万次阅读 多人点赞 2018-10-02 23:08:37
    多项式回归 多项式回归,回归函数是回归变量多项式的回归。多项式回归模型是线性回归模型的一种,此时回归函数关于回归系数是线性的。由于任一函数都可以用多项式逼近,因此多项式回归有着广泛应用。 直线回归研究...

    多项式回归

    多项式回归,回归函数是回归变量多项式的回归。多项式回归模型是线性回归模型的一种,此时回归函数关于回归系数是线性的。由于任一函数都可以用多项式逼近,因此多项式回归有着广泛应用。

    直线回归研究的是一个因变量与一个自变量之间的回归问题,但在实际情况中,影响因变量的自变量往往不止一个,例如:羊毛的产量受到绵羊体重、体长、胸围等影响,因此需要进行一个因变量与多个自变量间的回归分析,即多元回归分析。

    研究一个因变量与一个或多个自变量间多项式的回归分析方法,称为多项式回归(Polynomial Regression)。如果自变量只有一个时,称为一元多项式回归;如果自变量有多个时,称为多元多项式回归。在一元回归分析中,如果依变量y与自变量x的关系为非线性的,但是又找不到适当的函数曲线来拟合,则可以采用一元多项式回归。

    一元m次多项式回归方程为

    二元二次多项式回归方程为

     

    上图的数据,我们可以使用一元2次多项式来拟合,首先,一个标准的一元高阶多项式函数如下:

    m 表示多项式的阶数,x^{j}表示 x 的 j 次幂,w 则代表该多项式的系数。

    当我们使用上面的多项式去拟合散点时,需要确定两个要素,分别是:多项式系数 w 以及多项式阶数 m,这也是多项式的两个基本要素。当然也可以手动指定多项式的阶数m的大小,这样就只需要确定系数w的值了。得到以下公式:

    如何求解该公式呢?这里使用Scipy的方法。

    使用Scipy提供的最小二乘法函数得到最佳拟合参数:

    该方法:最小化一组方程的平方和(即可以用来实现最小二乘法) 

    import numpy as np
    from scipy.optimize import leastsq
    
    # 拟合数据集
    x = [4, 8, 12, 25, 32, 43, 58, 63, 69, 79]
    y = [20, 33, 50, 56, 42, 31, 33, 46, 65, 75]
    
    def fun(p, x):
        """
        定义想要拟合的函数
        """
        w0,w1 = p  #从参数p获得拟合的参数
        # 如果是二次多项式则:w0,w1,w2 = p ;return w0 + w1*x + w2*x*x  以此类推
        return w0 + w1*x
    
    def err(p, x, y):
        """
        定义误差函数
        """
        return fun(p,x) -y
    
    #定义起始的参数 即从 y = 1*x+1 开始,其实这个值可以随便设,只不过会影响到找到最优解的时间
    p0 = [1,1]   #p0 = [1,1,1]    w系数的个数[w0,w1,w2...]
    
    #将list类型转换为 numpy.ndarray 类型,最初我直接使用
    #list 类型,结果 leastsq函数报错,后来在别的blog上看到了,原来要将类型转
    #换为numpy的类型
    
    x1 = np.array(x)  
    y1 = np.array(y)
    
    xishu = leastsq(err, p0, args=(x1,y1))
    print(xishu[0])
    # xishu[0],即为获得的参数

    一般只要指定前三个参数就可以:

    • func 是我们自己定义的一个计算误差的函数,

    • x0 是计算的初始参数值

    • args 是指定func的其他参数

    通过实践后观察,上面实现1次多项式拟合(2次多项式,p0则需要3个值)但其效果都不是很好,所以下面修改代码尝试N(大于2)项拟合

    """
    	实现N次多项式拟合
    """
    def fit_func(p, x):
    	"""根据公式,定义 n 次多项式函数
    	"""
    	f = np.poly1d(p)   # 这里的np.poly1d函数是用来构造多项式使用的,默认格式为:ax**2+bx+c等,如:ax**3 + bx**2 + cx + d 以此类推
    	return f(x)
    
    def err_func(p, x, y):
    	"""残差函数(观测值与拟合值之间的差距)
    	"""
    	ret = fit_func(p, x) - y
    	return ret
    
    def n_poly(n):
    	"""n 次多项式拟合
    	"""
    	p_init = np.random.randn(n) # 生成 n 个随机数
    	parameters = leastsq(err_func, p_init, args=(np.array(x), np.array(y)))
    	return parameters[0]	# 返回多项式系数w0、w1、w2...
    
    k = n_poly(3)	# 与上面的二次多项式结果一致,只是公式顺序不同
    
    """绘制出 3,4,5,6,7, 8 次多项式的拟合图像
    """
    # 绘制拟合图像时需要的临时点
    x_temp = np.linspace(0, 80, 10000)
    # 绘制子图
    fig, axes = plt.subplots(2, 3, figsize=(15,10))
    
    axes[0,0].plot(x_temp, fit_func(n_poly(4), x_temp), 'r')
    axes[0,0].scatter(x, y)
    axes[0,0].set_title("m = 3")
    
    axes[0,1].plot(x_temp, fit_func(n_poly(5), x_temp), 'r')
    axes[0,1].scatter(x, y)
    axes[0,1].set_title("m = 4")
    
    axes[0,2].plot(x_temp, fit_func(n_poly(6), x_temp), 'r')
    axes[0,2].scatter(x, y)
    axes[0,2].set_title("m = 5")
    
    axes[1,0].plot(x_temp, fit_func(n_poly(7), x_temp), 'r')
    axes[1,0].scatter(x, y)
    axes[1,0].set_title("m = 6")
    
    axes[1,1].plot(x_temp, fit_func(n_poly(8), x_temp), 'r')
    axes[1,1].scatter(x, y)
    axes[1,1].set_title("m = 7")
    
    axes[1,2].plot(x_temp, fit_func(n_poly(9), x_temp), 'r')
    axes[1,2].scatter(x, y)
    axes[1,2].set_title("m = 8")
    plt.show()

    很简单,代码分为两部分,上面为主要的计算系数w的值,下面为直观查看每个次项拟合后的效果图,如下:

    可以清楚的看到当3次项(也就是m=3)时,效果还是一般,但从4次项(m=4)后,对于数据的拟合性就明显优于3次项了,当 m=8 时,曲线呈现出明显的震荡,这也就是线性回归实验中所讲到的过拟和(Overfitting)现象,后面再介绍如何解决这个问题。

    使用scikit-learn进行多项式拟合:

    对于一个二次多项式而言,我们知道它的标准形式为:y(x,w) = w_{0} + w_{1}x + w_{2}x^{2},但是,多项式回归其实相当于是线性回归的特殊形式(开头也提到)。例如,我们这里令x = x_{1}x^{2} = x_{2},那么原方程就转换为:y(x,w) = w_{0} + w_{1}x_{1} + w_{2}x_{2},这也就变成了多元线性回归。完成了一元高次多项式到多元一次项式之间的转换。(如下,看作将多元一次项合并为一个矩阵中线性求解

    举例说明,对于自变量向量 X 和因变量 y,如果 X

                          [[ 3]
              X  =     [-2]
                           [ 4]]

    则可以通过y = w_{0} + w_{1}x线性回归模型进行拟合。同样,如果对于一元二次多项式y(x,w) = w_{0} + w_{1}x + w_{2}x^{2},能得到x = x_{1}x^{2} = x_{2}构成的特征矩阵,即:

                                            [[ 3.  9.]
             X = \left [X X^{2} \right ] =       [-2.  4.]
                                             [ 4. 16.]]

    那么也就可以使用线性回归进行拟合了。

    所以这里有了一个方便的工具,scikit-learn 中,我们可以通过 PolynomialFeatures() 类自动产生多项式特征矩阵

    sklearn.preprocessing.PolynomialFeatures(degree=2, interaction_only=False, include_bias=True)

    • degree: 多项式次数,默认为 2 次多项式

    • interaction_only: 默认为 False,如果为 True 则产生相互影响的特征集。

    • include_bias: 默认为 True,包含多项式中的截距项。

    通过下面代码解决上面一样的问题:

    """
    	使用 PolynomialFeatures 自动生成特征矩阵
    """
    from sklearn.preprocessing import PolynomialFeatures
    
    x = np.array(x).reshape(len(x), 1) # 转换为列向量
    y = np.array(y).reshape(len(y), 1)
    
    poly_features = PolynomialFeatures(degree=2, include_bias=False)    # 特征矩阵模型构建用来多项式的特征矩阵
    poly_x = poly_features.fit_transform(x)    # 通过模型转换x数据
    
    """
        用线性回归拟合上面转换后的数据
    """
    from sklearn.linear_model import LinearRegression
    
    model = LinearRegression()
    model.fit(poly_x,y)		# 这里使用转换后的特征矩阵相当于将一元2次转换为二元一次
    # print(model.intercept_,model.coef_)
    
    """绘制拟合图像
    """
    x_temp = np.linspace(0, 80, 10000)
    x_temp = np.array(x_temp).reshape(len(x_temp),1)
    poly_x_temp = poly_features.fit_transform(x_temp)
    
    plt.plot(x_temp, model.predict(poly_x_temp), 'r')
    plt.scatter(x, y)
    plt.show()         # 得到的结果与上面用leastsq的二次项结果一致

    这里二次项的图(degree=2),若设置更高的次项3,4,5(degree=3,4,5),则可以得到上面leastsq方法相同的效果,只需要通过PolynomialFeatures方法生成对应次项的特征矩阵就行。

    评价指标

    可以使用前一篇文章提到的 平均绝对误差(MAE)、均方误差(MSE)等方法来衡量,具体可以使用sklearn中的以下两个方法:

    from sklearn.metrics import mean_absolute_error
    from sklearn.metrics import mean_squared_error

    2次多项式不一定比线性回归的效果好,需要根据具体的测试结果做决定,可以试试更高次的多项式回归预测 ,下面我们便来验证以一下。

    make_pipeline通道:

    通过实例化 make_pipeline 管道类,实现调用一次 fitpredict 方法即可应用于所有预测器。make_pipeline 是使用 sklearn 过程中的技巧创新,其可以将一个处理流程封装起来使用。 更详细的使用可以参考这里

    上面的多项式回归中,我们需要先使用 PolynomialFeatures 完成特征矩阵转换,再放入 LinearRegression 中。那么,PolynomialFeatures + LinearRegression 这一个处理流程,就可以通过 make_pipeline 封装起来使用。

    以下数据集并非上面的x,y,如下数据(将Year作为特征列train_x,Values为目标值train_y,且数据是按0.7比例分割为训练、测试集):

    """更高次多项式回归预测
    """
    from sklearn.pipeline import make_pipeline
    
    train_x = train_x.reshape(len(train_x),1)
    test_x = test_x.reshape(len(test_x),1)
    train_y = train_y.reshape(len(train_y),1)
    
    for m in [3, 4, 5]:
        model = make_pipeline(PolynomialFeatures(m, include_bias=False), LinearRegression())
        model.fit(train_x, train_y)
        pre_y = model.predict(test_x)
        print("{} 次多项式回归平均绝对误差: ".format(m), mean_absolute_error(test_y, pre_y.flatten()))
        print("{} 次多项式均方根误差: ".format(m), mean_squared_error(test_y, pre_y.flatten()))
        print("---")

    可以看到高次项的误差都比线性回归要低,而2次项则要高,所以对于模型均需要进行验证后使用。

    好了,上面介绍了 多项式回归的原理与Scipy实现、sklearn构建特征矩阵转为线性运算、Pipeline方便的通道运算、以及误差评判,但还有一个很重要的问题,那就是如何选择最佳的n次项?

    几次项才是最佳的选择?

    其实这个问题很简单,我们可以设置一个误差指标(MSE、MAE等),然后绘制增加次项后,预测结果的误差值图。观察图形来选择一个合适的次项点(类似肘部法则也可以作为参考):

    """
    	计算 m 次多项式回归预测结果的 MSE 评价指标并绘图
    """
    mse = [] # 用于存储各最高次多项式 MSE 值
    m = 1 # 初始 m 值
    m_max = 10 # 设定最高次数
    while m <= m_max:
        model = make_pipeline(PolynomialFeatures(m, include_bias=False), LinearRegression())
        model.fit(train_x, train_y) # 训练模型
        pre_y = model.predict(test_x) # 测试模型
        mse.append(mean_squared_error(test_y, pre_y.flatten())) # 计算 MSE
        m = m + 1
    
    # print("MSE 计算结果: ", mse)
    # 绘图
    plt.plot([i for i in range(1, m_max + 1)], mse, 'b')
    plt.scatter([i for i in range(1, m_max + 1)], mse)
    
    # 绘制图名称等
    plt.title("MSE of m degree of polynomial regression")
    plt.xlabel("m")
    plt.ylabel("MSE")
    plt.show()

    如上图,可以明显看到当次数为3时,误差指标已经趋近于平稳了,所以这里选择3最好,当次数项越多可能会出现过拟合的问题,模型的泛化能力会降低。

     

    参考文章:

    https://baike.baidu.com/item/%E5%A4%9A%E9%A1%B9%E5%BC%8F%E5%9B%9E%E5%BD%92/21505384?fr=aladdin

    https://blog.csdn.net/lanchunhui/article/details/50521648

    展开全文
  • PyTorch基础入门三:PyTorch搭建多项式回归模型  1)理论简介 对于一般的线性回归模型,由于该函数拟合出来的是一条直线,所以精度欠佳,我们可以考虑多项式回归来拟合更多的模型。所谓多项式回归,其本质也是线性...
  • 有时候,一次项表达式进行回归误差比较大。给定这样的数据集,以y = 0.5 * X^2 + X + 2加入噪声生成,其图像    用线性回归获取回归方程,并用预测结果对比实际情况,得到    红色直线是通过回归方程得到的所有...
  • 文章目录前言PolynomialFeatures详细探讨如何实现多项式回归代码实现:正规方程验证 前言 在机器学习入门(六)中,已经通过pipeline快速实现了多项式回归。代码如下: PolyRegr = Pipeline([ ('poly',Polynomial...
  • 多项式回归法估计一个因变量与一个自变量之间的多项式关系
  • python多项式回归Polynomial regression in an improved version of linear regression. If you know linear regression, it will be simple for you. If not, I will explain the formulas here in this article. ...

    python多项式回归

    Polynomial regression in an improved version of linear regression. If you know linear regression, it will be simple for you. If not, I will explain the formulas here in this article. There are other advanced and more efficient machine learning algorithms are out there. But it is a good idea to learn linear based regression techniques. Because they are simple, fast, and works with very well known formulas. Though it may not work with a complex set of data.

    线性回归的改进版本中的多项式回归。 如果您知道线性回归,那么对您来说很简单。 如果没有,我将在本文中解释这些公式。 还有其他先进且更有效的机器学习算法。 但是,学习基于线性的回归技术是一个好主意。 因为它们简单,快速并且可以使用众所周知的公式。 尽管它可能不适用于复杂的数据集。

    多项式回归公式 (Polynomial Regression Formula)

    Linear regression can perform well only if there is a linear correlation between the input variables and the output variable. As I mentioned before polynomial regression is built on linear regression. If you need a refresher on linear regression, here is the link to linear regression:

    仅当输入变量和输出变量之间存在线性相关性时,线性回归才能很好地执行。 如前所述,多项式回归建立在线性回归的基础上。 如果您需要线性回归的基础知识,请访问以下线性回归链接:

    Polynomial regression can find the relationship between input features and the output variable in a better way even if the relationship is not linear. It uses the same formula as the linear regression:

    多项式回归可以更好地找到输入要素与输出变量之间的关系,即使该关系不是线性的。 它使用与线性回归相同的公式:

    Y = BX + C

    Y = BX + C

    I am sure, we all learned this formula in school. For linear regression, we use symbols like this:

    我敢肯定,我们都在学校学过这个公式。 对于线性回归,我们使用如下符号:

    Here, we get X and Y from the dataset. X is the input feature and Y is the output variable. Theta values are initialized randomly.

    在这里,我们从数据集中获得X和Y。 X是输入要素,Y是输出变量。 Theta值是随机初始化的。

    For polynomial regression, the formula becomes like this:

    对于多项式回归,公式如下所示:

    Image for post

    We are adding more terms here. We are using the same input features and taking different exponentials to make more features. That way, our algorithm will be able to learn about the data better.

    我们在这里添加更多术语。 我们使用相同的输入功能,并采用不同的指数以制作更多功能。 这样,我们的算法将能够更好地了解数据。

    The powers do not have to be 2, 3, or 4. They could be 1/2, 1/3, or 1/4 as well. Then the formula will look like this:

    幂不必为2、3或4。它们也可以为1 / 2、1 / 3或1/4。 然后,公式将如下所示:

    Image for post

    成本函数和梯度下降 (Cost Function And Gradient Descent)

    Cost function gives an idea of how far the predicted hypothesis is from the values. The formula is:

    成本函数给出了预测假设与值之间的距离的概念。 公式为:

    Image for post

    This equation may look complicated. It is doing a simple calculation. First, deducting the hypothesis from the original output variable. Taking a square to eliminate the negative values. Then dividing that value by 2 times the number of training examples.

    这个方程可能看起来很复杂。 它正在做一个简单的计算。 首先,从原始输出变量中减去假设。 取平方消除负值。 然后将该值除以训练示例数的2倍。

    What is gradient descent? It helps in fine-tuning our randomly initialized theta values. I am not going to the differential calculus here. If you take the partial differential of the cost function on each theta, we can derive these formulas:

    什么是梯度下降? 它有助于微调我们随机初始化的theta值。 我不打算在这里进行微积分。 如果对每个θ取成本函数的偏微分,则可以得出以下公式:

    Image for post

    Here, alpha is the learning rate. You choose the value of alpha.

    在这里,alpha是学习率。 您选择alpha的值。

    多项式回归的Python实现 (Python Implementation of Polynomial Regression)

    Here is the step by step implementation of Polynomial regression.

    这是多项式回归的逐步实现。

    1. We will use a simple dummy dataset for this example that gives the data of salaries for positions. Import the dataset:

      在此示例中,我们将使用一个简单的虚拟数据集,该数据集提供职位的薪水数据。 导入数据集:
    import pandas as pd
    import numpy as np
    df = pd.read_csv('position_salaries.csv')
    df.head()
    Image for post

    2. Add the bias column for theta 0. This bias column will only contain 1. Because if you multiply 1 with a number it does not change.

    2.添加theta 0的偏差列。该偏差列将仅包含1。因为如果将1乘以数字,它不会改变。

    df = pd.concat([pd.Series(1, index=df.index, name='00'), df], axis=1)
    df.head()
    Image for post

    3. Delete the ‘Position’ column. Because the ‘Position’ column contains strings and algorithms do not understand strings. We have the ‘Level’ column to represent the positions.

    3.删除“位置”列。 由于“位置”列包含字符串,并且算法无法理解字符串。 我们有“级别”列来代表职位。

    df = df.drop(columns='Position')

    4. Define our input variable X and the output variable y. In this example, ‘Level’ is the input feature and ‘Salary’ is the output variable. We want to predict the salary for levels.

    4.定义我们的输入变量X和输出变量y。 在此示例中,“级别”是输入要素,而“薪水”是输出变量。 我们要预测各个级别的薪水。

    y = df['Salary']
    X = df.drop(columns = 'Salary')
    X.head()
    Image for post

    5. Take the exponentials of the ‘Level’ column to make ‘Level1’ and ‘Level2’ columns.

    5.以“级别”列的指数表示“级别1”和“级别2”列。

    X['Level1'] = X['Level']**2
    X['Level2'] = X['Level']**3
    X.head()
    Image for post

    6. Now, normalize the data. Divide each column by the maximum value of that column. That way, we will get the values of each column ranging from 0 to 1. The algorithm should work even without normalization. But it helps to converge faster. Also, calculate the value of m which is the length of the dataset.

    6.现在,标准化数据。 将每一列除以该列的最大值。 这样,我们将获得每列的值,范围从0到1。即使没有规范化,该算法也应该起作用。 但这有助于收敛更快。 同样,计算m的值,它是数据集的长度。

    m = len(X)
    X = X/X.max()

    7. Define the hypothesis function. That will use the X and theta to predict the ‘y’.

    7.定义假设函数。 这将使用X和theta来预测“ y”。

    def hypothesis(X, theta):
    y1 = theta*X
    return np.sum(y1, axis=1)

    8. Define the cost function, with our formula for cost-function above:

    8.使用上面的成本函数公式定义成本函数:

    def cost(X, y, theta):
    y1 = hypothesis(X, theta)
    return sum(np.sqrt((y1-y)**2))/(2*m)

    9. Write the function for gradient descent. We will keep updating the theta values until we find our optimum cost. For each iteration, we will calculate the cost for future analysis.

    9.编写梯度下降函数。 我们将不断更新theta值,直到找到最佳成本。 对于每次迭代,我们将计算成本以供将来分析。

    def gradientDescent(X, y, theta, alpha, epoch):
    J=[]
    k=0
    while k < epoch:
    y1 = hypothesis(X, theta)
    for c in range(0, len(X.columns)):
    theta[c] = theta[c] - alpha*sum((y1-y)* X.iloc[:, c])/m
    j = cost(X, y, theta)
    J.append(j)
    k += 1
    return J, theta

    10. All the functions are defined. Now, initialize the theta. I am initializing an array of zero. You can take any other random values. I am choosing alpha as 0.05 and I will iterate the theta values for 700 epochs.

    10.定义了所有功能。 现在,初始化theta。 我正在初始化零数组。 您可以采用任何其他随机值。 我选择alpha为0.05,我将迭代700个纪元的theta值。

    theta = np.array([0.0]*len(X.columns))
    J, theta = gradientDescent(X, y, theta, 0.05, 700)

    11. We got our final theta values and the cost in each iteration as well. Let’s find the salary prediction using our final theta.

    11.我们还获得了最终的theta值以及每次迭代的成本。 让我们使用最终的theta查找薪水预测。

    y_hat = hypothesis(X, theta)

    12. Now plot the original salary and our predicted salary against the levels.

    12.现在根据水平绘制原始薪水和我们的预测薪水。

    %matplotlib inline
    import matplotlib.pyplot as plt
    plt.figure()
    plt.scatter(x=X['Level'],y= y)
    plt.scatter(x=X['Level'], y=y_hat)
    plt.show()
    Image for post

    Our prediction does not exactly follow the trend of salary but it is close. Linear regression can only return a straight line. But in polynomial regression, we can get a curved line like that. If the line would not be a nice curve, polynomial regression can learn some more complex trends as well.

    我们的预测并不完全符合薪资趋势,但接近。 线性回归只能返回一条直线。 但是在多项式回归中,我们可以得到这样的曲线。 如果该线不是一条好曲线,则多项式回归也可以学习一些更复杂的趋势。

    13. Let’s plot the cost we calculated in each epoch in our gradient descent function.

    13.让我们绘制我们在梯度下降函数中每个时期计算的成本。

    plt.figure()
    plt.scatter(x=list(range(0, 700)), y=J)
    plt.show()
    Image for post

    The cost fell drastically in the beginning and then the fall was slow. In a good machine learning algorithm, cost should keep going down until the convergence. Please feel free to try it with a different number of epochs and different learning rates (alpha).

    成本从一开始就急剧下降,然后下降缓慢。 在一个好的机器学习算法中,成本应该一直下降直到收敛。 请随意尝试不同的时期和不同的学习率(alpha)。

    Here is the dataset: salary_data

    这是数据集: salary_data

    Follow this link for the full working code: Polynomial Regression

    请点击以下链接获取完整的工作代码: 多项式回归

    推荐阅读: (Recommended reading:)

    翻译自: https://towardsdatascience.com/polynomial-regression-from-scratch-in-python-1f34a3a5f373

    python多项式回归

    展开全文
  • 多元多项式回归的代码 该代码将多变量多项式方程拟合到多变量输出。 我们首先准备数据如下 wb_train = pd.read_excel(r'C:\ Users \ blah \ training.xlsx')wb_targets = pd.read_excel(r'C:\ Users \ blahD \...
  • 3,多项式回归(数据升维).ipynb
  • 多项式回归.py

    2019-10-03 21:40:24
    多项式回归代码,比较适合回归型问题,非常有用,赶快下载吧
  • python多项式回归Video Link 影片连结 You can view the code used in this Episode here: SampleCode 您可以在此处查看 此剧 集中使用的代码: SampleCode 导入我们的数据 (Importing our Data) The first step ...

    python多项式回归

    Video Link

    影片连结

    You can view the code used in this Episode here: SampleCode

    您可以在此处查看 此剧 集中使用的代码: SampleCode

    导入我们的数据 (Importing our Data)

    The first step is to import our data into python.

    第一步是将我们的数据导入python。

    We can do that by going on the following link: Data

    我们可以通过以下链接来做到这一点: 数据

    Click on “code” and download ZIP.

    单击“代码”并下载ZIP。

    Locate WeatherDataP.csv and copy it into your local disc under a new file called ProjectData

    找到WeatherDataP.csv并将其复制到本地磁盘下名为ProjectData的新文件下

    Note: WeatherData.csv and WeahterDataM.csv were used in Simple Linear Regression and Multiple Linear Regression.

    注意:WeatherData.csv和WeahterDataM.csv用于简单线性回归多重线性回归

    Now we are ready to import our data into our Notebook:

    现在我们准备将数据导入到笔记本中:

    How to set up a new Notebook can be found at the start of Episode 4.3

    如何设置新笔记本可以在第4.3节开始时找到

    Note: Keep this medium post on a split screen so you can read and implement the code yourself.

    注意:请将此帖子张贴在分屏上,以便您自己阅读和实现代码。

    # Import Pandas Library, used for data manipulation
    # Import matplotlib, used to plot our data
    # Import numpy for linear algebra operationsimport pandas as pd
    import matplotlib.pyplot as plt
    import numpy as np
    # Import our WeatherDataP.csv and store it in the variable rweather_data_pweather_data_p = pd.read_csv("D:\ProjectData\WeatherDataP.csv")
    # Display the data in the notebookweather_data_p
    Image for post

    绘制数据 (Plotting our Data)

    In order to check what kind of relationship Pressure forms with Humidity, we plot our two variables.

    为了检查压力与湿度之间的关系,我们绘制了两个变量。

    # Set our input x to Pressure, use [[]] to convert to 2D array suitable for model inputX = weather_data_p[["Pressure (millibars)"]]
    y = weather_data_p.Humidity
    # Produce a scatter graph of Humidity against Pressureplt.scatter(X, y, c = "black")
    plt.xlabel("Pressure (millibars)")
    plt.ylabel("Humidity")
    Image for post

    Here we see Humidity vs Pressure forms a bowl shaped relationship, reminding us of the function: y = 𝑥² .

    在这里,我们看到湿度与压力之间呈碗形关系,使我们想起了函数y =𝑥²。

    预处理我们的数据 (Preprocessing our Data)

    This is the additional step we apply to polynomial regression, where we add the feature 𝑥² to our Model.

    这是我们应用于多项式回归的附加步骤 ,在此步骤中将特征𝑥²添加到模型中。

    # Import the function "PolynomialFeatures" from sklearn, to preprocess our data
    # Import LinearRegression model from sklearnfrom sklearn.preprocessing import PolynomialFeatures
    from sklearn.linear_model import LinearRegression
    # Set PolynomialFeatures to degree 2 and store in the variable pre_process
    # Degree 2 preprocesses x to 1, x and x^2
    # Degree 3 preprocesses x to 1, x, x^2 and x^3
    # and so on..pre_process = PolynomialFeatures(degree=2)# Transform our x input to 1, x and x^2X_poly = pre_process.fit_transform(X)# Show the transformation on the notebookX_poly
    Image for post

    e+.. refers to the position of the decimal place.

    e + ..指小数位的位置。

    E.g1.0e+00 = 1.0 [ keep the decimal point where it is ]1.0144e+03 = 1014.4 [ Move the decimal place 3 places to the right ]1.02900736e+06 = 1029007.36 [ Move the decimal place 6 to places to the right ]

    例如 1.0e + 00 = 1.0 [保留小数点处的位置] 1.0144e + 03 = 1014.4 [将小数位右移3位] 1.02900736e + 06 = 1029007.36 [将小数点6向右移动]

    — — — — — — — — — — — — — — — — — —

    — — — — — — — — — — — — — — — — — — — —

    The code above makes the following Conversion:

    上面的代码进行了以下转换:

    Image for post

    Notice that there is a hidden column of 1’s which can be thought of as the variable associated with θ₀. Since θ₀ × 1 = θ₀ this is often left out.

    请注意,有一个隐藏的1列,可以将其视为与θ₀相关的变量。 由于θ₀×1 =θ₀,因此经常被忽略。

    — — — — — — — — — — — — — — — — — —

    — — — — — — — — — — — — — — — — — — — —

    实现多项式回归 (Implementing Polynomial Regression)

    The method here remains the same as multiple linear regression in python, but here we are fitting our regression model to the preprocessed data:

    此处的方法与python中的多元线性回归相同,但此处我们将回归模型拟合为预处理的数据:

    pr_model = LinearRegression()# Fit our preprocessed data to the polynomial regression modelpr_model.fit(X_poly, y)# Store our predicted Humidity values in the variable y_newy_pred = pr_model.predict(X_poly)# Plot our model on our dataplt.scatter(X, y, c = "black")
    plt.xlabel("Pressure (millibars)")
    plt.ylabel("Humidity")
    plt.plot(X, y_pred)
    Image for post

    We can extract θ₀, θ₁ and θ₂ using the following code:

    我们可以使用以下代码提取θ₀,θ₁和θ2

    theta0 = pr_model.intercept_
    _, theta1, theta2 = pr_model.coef_
    theta0, theta1, theta2

    A “_” is used to ignore the first value in pr_model.coef as this is given by default as 0. The other two co-efficients are labelled theta1 and theta 2 respectively.

    _”用于忽略pr_model.coef中的第一个值,因为默认情况下该值为0。其他两个系数分别标记为theta1和theta 2。

    Image for post

    Giving our polynomial regression model roughly as:

    大致给出我们的多项式回归模型:

    Image for post

    使用我们的回归模型进行预测 (Using our Regression Model to make predictions)

    # Predict humidity for a pressure of 1007 millibars
    # Tranform 1007 to 1, 1007, 1007^2 suitable for input, using
    # pre_process.fit_transformy_new = pr_model.predict(pre_process.fit_transform([[1007]]))
    y_new
    Image for post

    Here we expect a Humidity value of 0.7164631 for a pressure reading of 1007 millibars.

    在这里,对于1007毫巴的压力读数,我们期望的湿度值为0.7164631。

    We can plot this point on our data plot using the following code:

    我们可以使用以下代码在数据图上绘制该点:

    plt.scatter(1007, y_new, c = "red")
    Image for post

    评估我们的模型 (Evaluating our Model)

    To evaluate our model we are going to be using mean squared error (MSE), discussed in the previous episode, the function can easily be imported from sklearn.

    为了评估我们的模型,我们将使用上一集中讨论的均方误差(MSE) ,可以轻松地从sklearn导入函数。

    from sklearn.metrics import mean_squared_error
    mean_squared_error(y, y_pred)
    Image for post

    The mean squared error for our regression model is given by: 0.003358..

    我们的回归模型的均方误差为:0.003358 ..

    Image for post

    If we want to change our model to include 𝑥³ we can do so by simply changing PolynomialFeatures to degree 3:

    如果要更改模型以包括𝑥³ ,可以通过将PolynomialFeatures更改为3级来实现

    pre_process = PolynomialFeatures(degree=3)

    Let’s check if this has decreased our mean squared error:

    让我们检查一下这是否降低了均方误差:

    Image for post

    Indeed it has.

    确实有。

    You can change the degree used in PolynomialFeatures to anything you like and see for yourself what effect this has on our MSE.

    您可以将PolynomialFeatures中使用的度数更改为您喜欢的任何值,并亲自查看这对我们的MSE有什么影响。

    Ideally we want to choose the model that:

    理想情况下,我们要选择以下模型:

    • Has the lowest MSE

      MSE最低

    • Does not over-fit our data

      不会过度拟合我们的数据

    It is important that we plot our model on our data to ensure we don’t end up with the model shown at the end of Episode 4.6, which had an extremely low MSE but over-fitted our data.

    重要的是, 我们需要在数据上绘制模型,以确保最终不会出现第4.6集末显示的模型,该模型的MSE极低,但数据过拟合。

    上一集 - 下一集 (Prev EpisodeNext Episode)

    如有任何疑问,请留在下面! (If you have any questions please leave them below!)

    Image for post

    翻译自: https://medium.com/ai-in-plain-english/implementing-polynomial-regression-in-python-d9aedf520d56

    python多项式回归

    展开全文
  • 多项式回归-源码

    2021-02-13 02:28:54
    多项式回归

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,468
精华内容 10,587
关键字:

多项式回归