精华内容
下载资源
问答
  • 转载自:线性回归与非线性回归:1.0一元线性回归与代价函数(损失函数回归分析:用来建立方程模拟两个或者多个变量之间如何关联 因变量:被预测的变量(结果/标签),输出 自变量:被用来进行预测的变量(特征)...

    转载自:线性回归与非线性回归:1.0一元线性回归与代价函数(损失函数)

    • 回归分析:用来建立方程模拟两个或者多个变量之间如何关联
    • 因变量:被预测的变量(结果/标签),输出
    • 自变量:被用来进行预测的变量(特征),输入
    • 一元线性回归:包含一个自变量与一个因变量,并且变量的关系用一条直线来模拟

    一元线性回归

    公式:\(h_\theta = \theta_0+\theta_1x\)
    方程对应的图像是一条直线,称作回归线。其中\(\theta_1\)为回归线的斜率\(\theta_0\)为回归的截距
    相关性:\[ \begin{cases} 正相关:\theta_1>0 \\ 不相关:\theta_1 = 0 \\ 负相关:\theta_1<0 \end{cases}\]

    代价函数

    一般使用最小二乘法,真实值\(y\),预测值\(h_\theta(x)\),则误差平方为\((y-h_\theta(x))^2\),找到合适的参数,使得误差平方平方和最小\[J(\theta_0 , \theta_1) = \frac{1}{2m}\sum_{i=1}^m(y-h_\theta(x))^2\]
    其中共有m个样本点,乘以1/2是为了方便计算,如求导。

    相关系数

    定义:相关关系是一种非确定性的关系,相关系数是研究变量之间线性相关程度的量。

    线性相关:在向量空间V的一组向量:\(A:\alpha_1,\alpha_2,\ldots\alpha_m\),如果存在不全为零的数\(k_1,k_2,\ldots k_m\),使\[k_1\alpha_1+k_2\alpha_2+\cdots k_m\alpha_m = O\]则称向量组A是线性相关的,否则\(k_1,k_2,\ldots k_m\)全为0,称其为线性无关的。

    公式:\[r_{xy} = \frac{\sum (x_i - \overline x)(y_i - \overline y)}{\sqrt{\sum (x_i - \overline x)^2\sum(y_i - \overline y)^2}} = \frac{cov(x,y)}{\sqrt{var[x]var[y]}}\]

    决定系数

    定义:相关系数\(R^2\)是用来描述两个变量之间的线性关系的,但决定系数的适用范围更广,可以用于描述非线性或者有两个及两个以上自变量的相关关系。它可以用来评估模型的效果。
    总平方和(SST):\(\sum_{i=1}^{n}(y_i - \overline y)^2\)
    回归平方和(SSR):\(\sum_{i=1}^{n}(\hat y-\overline y)^2\)
    残差平方和(SSE):\(\sum_{i=1}^{n}(y_i-\hat y)^2\)
    \(y_i\)真实值\(\overline y\)真实值的平均值\(\hat y\)预测值
    它们三者的关系是:\(SST=SSR+SSE\)
    决定系数:\(R^2 = \frac{SSR}{SST} = 1-\frac{SSE}{SST}\)

    用梯度下降法求解线性回归

    一元线性回归方程:\(h_\theta = \theta_0+\theta_1x\)
    参数:\(\theta_0\),\(\theta_1\)
    代价函数:\(J(\theta_0 , \theta_1) = \frac{1}{2m}\sum_{i=1}^m(y-h_\theta(x))^2\)
    目标:\(min J(\theta_0 , \theta_1)\)
    梯度下降法:不断改变\(\theta_0\),\(\theta_1\),直到\(J(\theta_0 , \theta_1)\)达到一个全局最小或者局部最小\[repeat \ until \ convergence\{ \\ \theta_j:=\theta_j - \alpha\frac{\partial}{\partial \theta_j}J(\theta_0,\theta_1) \\ \} \ (for \ j=0 \ and \ j=1)\] \(\alpha\)为学习率,当学习率过大会造成不收敛也就是找不到一个全局最小值或者局部最小值,学习率过小会浪费大量的时间进行计算。
    正确的做法:同步更新\[tempt0:=\theta_0 - \alpha\frac{\partial}{\partial \theta_0}J(\theta_0,\theta_1)\]\[tempt1:=\theta_1 - \alpha\frac{\partial}{\partial \theta_1}J(\theta_0,\theta_1)\]\[\theta_0:=tempt0\]\[\theta_1:=tempt1\]
    使用梯度下降:\[repeat \ until \ convergence\{ \theta_0:=\theta_0-\alpha\frac{1}{m}\sum_{i=1}^m(h_\theta(x_i)-y_i) \\ \theta_1:=\theta_1-\alpha\frac{1}{m}\sum_{i=1}^m(h_\theta(x_i)-y_i)*x_i\\ \}\]

    实战

    import numpy as np
    import matplotlib.pyplot as plt
     
    #载入数据
    data = np.genfromtxt("data.csv",delimiter=",")#加载文件,分隔符为逗号
    x_data = data[:,0]#存储第0列的所有数据
    y_data = data[:,1]#存储第1列的所有数据
     
    #学习率
    lr = 0.0001
    #截距
    b = 0.0
    #斜率
    k = 0.0
    #最大迭代次数
    epochs = 50
     
    #最小二乘法
    def compute_error(b, k, x_data, y_data):
        totalError = 0
        for i in range(0,len(x_data)):
            totalError += (y_data[i] - (k * x_data[i] + b)) ** 2
        return totalError / float(len(x_data)) / 2.0
     
     
    #梯度下降法求最小值
    def gradient_descent_runner(x_data, y_data, b, k, lr, epochs):
        #计算总数据量
        m = len(x_data)
        #循环epochs次
        for i in range(epochs):
            b_grade = 0
            k_grade = 0
            #计算梯度总和在求平均
            for j in range(0, len(x_data)):
                b_grade += -(1/m) * (y_data[j] - (k * x_data[j] + b))
                k_grade += -(1/m) * (y_data[j] - (k * x_data[j] + b)) * x_data[j]
            #更新学习率
            b = b - (lr * b_grade)
            k = k - (lr * k_grade)
     
        return b,k 
     
     
    print("Starting b = {0}, k = {1}, error = {2}".format(b, k, compute_error(b, k, x_data, y_data)))
    print("Running...")
    b,k = gradient_descent_runner(x_data, y_data, b, k, lr, epochs)
    print("After {0} iterations b = {1}, k = {2}, error = {3}".format(epochs, b, k, compute_error(b, k, x_data, y_data)))
     
    #画图
    plt.plot(x_data, y_data, 'b.')
    plt.plot(x_data, k*x_data+b, 'r')
    plt.show()

    转载于:https://www.cnblogs.com/xym4869/p/11309134.html

    展开全文
  • 一元线性回归:包含一个自变量与一个因变量,并且变量的关系用一条直线来模拟 一元线性回归 公式: 这个方程对应的图像是一条直线,称作回归线。其中,为回归线的斜率,为回归的截距。 相关性: 正...
    • 回归分析:用来建立方程模拟两个或者多个变量之间如何关联
    • 因变量:被预测的变量(结果/标签),输出
    • 自变量:被用来进行预测的变量(特征),输入
    • 一元线性回归:包含一个自变量与一个因变量,并且变量的关系用一条直线来模拟

    • 一元线性回归
       

    • 公式:   \bg_white \small h_{\theta }(x)=\theta _{0}+\theta _{1}x

      这个方程对应的图像是一条直线,称作回归线。其中,\theta _{1} 为回归线的斜率,\theta _{0} 为回归的截距。
       
    • 相关性:

      正相关:\theta _{1}>0
      不相关:\theta _{1}=0  
      负相关:\theta _{1}<0
       
    • 代价函数
       

    • 一般使用最小二乘法:真实值 y,预测值 h_{\theta }(x),则误差平方为(y-h_{\theta }(x))^{2},找到合适的参数,使得误差平方平方和最小
                                                     \underset{\theta _{0},\theta _{1}}{mininmize}J(\theta _{0},\theta _{1})=\frac{1}{2m} \sum_{i=1}^{m}(y_{i}-h_{\theta }(x_{i}))^2
    • 其中共有m个样本点,乘以 \frac{1}{2}  是为了方便计算,如求导。

       
    • 相关系数
       

    • 定义:相关关系是一种非确定性的关系,相关系数是研究变量之间线性相关程度的量。
       
    • 公式:  r_{xy}=\frac{\sum (x_{i}-\overline{x}) (y_{i}-\overline{y})}{\sqrt{\sum (x_{i}-\overline{x})^2\sum (y_{i}-\overline{y})^2}}=\frac{cov(x,y)}{\sqrt{var[x]var[y]}}  

       
    • 决定系数
       

    • 定义:相关系数R^{2}是用来描述两个变量之间的线性关系的,但决定系数的适用范围更广,可以用于描述非线性或者有两个及两个以上自变量的相关关系。它可以用来评估模型的效果。
       
    • 总平方和(SST):\sum_{i=1}^{n}(y_{i}-\overline{y})^2
       
    • 回归平方和(SSR):\sum_{i=1}^{n}(\widehat{y}-\overline{y})^2
       
    • 残差平方和(SSE):\sum_{i=1}^{n}(y_{i}-\widehat{y})^2 
       
    • y_{i} 真实值   \overline{y} 真实值的平均值  \widehat{y} 预测值
       
    • 它们三者的关系是:SST=SSR+SSE
       
    • 决定系数:R^{2}=\frac{SSR}{SST}=1-\frac{SSE}{SST}

       
    • 用梯度下降法求解线性回归
       

    • 一元线性回归方程:\bg_white \small h_{\theta }(x)=\theta _{0}+\theta _{1}x
       
    • 参数:\theta _{0}, \theta _{1}
    • 代价函数:J(\theta _{0},\theta _{1})=\frac{1}{2m} \sum_{i=1}^{m}(y_{i}-h_{\theta }(x_{i}))^2 
       
    • 目标:\underset{\theta _{0},\theta _{1}}{mininmize}J(\theta _{0},\theta _{1}) 
       
    • 梯度下降法:不断改变 \theta _{0}, \theta _{1} 直到  J(\theta _{0},\theta _{1}) 达到一个全局最小或者局部最小。

      repeat until convergence{
         \theta _{j} :=\theta _{j}-\alpha \frac{\partial }{\partial \theta _{j}}J(\theta _{0},\theta _{1})  (for j = 0 and j = 1)
    }
    \alpha为学习率,当学习率过大会造成不收敛也就是找不到一个全局最小值或者局部最小值,学习率过小会浪费大量的时间进行计算。

    正确的做法:同步更新
    tempt0 :=\theta _{0}-\alpha \frac{\partial }{\partial \theta _{0}}J(\theta _{0},\theta _{1})
    tempt1 :=\theta _{1}-\alpha \frac{\partial }{\partial \theta _{1}}J(\theta _{0},\theta _{1})
    \theta _{0}:=temp0
    \theta _{1}:=temp1

    • 使用梯度下降

    repeat until convergence{
         \small \theta _{0} :=\theta _{0}-\alpha \frac{1}{m} \sum_{i=1}^{m}(h_{\theta }(x_i)-y_i)
        \small \theta _{1} :=\theta _{1}-\alpha \frac{1}{m} \sum_{i=1}^{m}(h_{\theta }(x_i)-y_i)*x_i  
    }

     

     

    展开全文
  • 我们准备建立一个如下的一个含有一个隐藏层的...最终实现一个一元回归的分析模型,也就会线性回归。 我们会生成一个y = 4 * x + 1 的线性曲线,随机生成输入数(满足偏差为0.05的正态分布的噪声数)。 import ten...

      我们准备建立一个如下的一个含有一个隐藏层的神经网络去实现回归分析,这个网络应有输入层、输出层、和隐藏层。                 

                                   

    最终实现一个一元回归的分析模型,也就会线性回归。

    我们会生成一个y = 4 * x + 1 的线性曲线,随机生成输入数(满足偏差为0.05的正态分布的噪声数)。

    import tensorflow as tf
    import numpy as np
    
    inputX = np.random.rand(3000,1)
    noise = np.random.normal(0 , 0.05 , inputX.shape)
    outputY = inputX * 4 + 1 + noise
    
    #构建第一层
    #weight1 和 bias1是隐藏层的变量 这个变量在后续的图的计算过程中需要根据误差算法不断的重新赋值
    weight1 = tf.Variable(np.random.rand(inputX.shape[1],4))#服从“0~1”均匀分布的随机样本值。随机样本取值范围是[0,1),不包括1
    bias1 = tf.Variable(np.random.rand(inputX.shape[1],4))#.shape【1】每个维度有几个数据 【0】是有几个维度
    x1 = tf.placeholder(tf.float64 , [None , 1])#x1的shape是列是1,行不定
    y1_ = tf.matmul(x1 , weight1) + bias1
    
    
    y = tf.placeholder(tf.float64 , [None , 1])
    loss = tf.reduce_mean(tf.reduce_sum(tf.square((y1_ - y)) , reduction_indices = [1]))
    #tf.reduce_mean计算张量tensor沿着指定的数轴(tensor的某一维度)上的的平均值损失函数 reduce_sum( ) 是求和函数 使用的是最小二乘法 reduction_indices表示在第一个维度
    train = tf.train.GradientDescentOptimizer(0.25).minimize(loss) #选择梯度下降法训练
    
    init = tf.global_variables_initializer()#初始化模型的参数
    sess = tf.Session()
    sess.run(init)
    
    #开始训练
    for i in range(1000):
        sess.run(train , feed_dict = {x1 : inputX , y : outputY})
    
    #打印weight 和 bias 这个模型最重要的参数    
    print(weight1.eval(sess))
    print('--------------------------')
    print(bias1.eval(sess))
    print('--------------------------resul-------------------------')
    
    x_data = np.matrix([[1] , [2] , [3]])#将1 2 3 当做测试数据看输出数据
    print(sess.run(y1_,feed_dict = {x1 : x_data}))#调用y1_模型 此时y1_作为模型被存储

                  

    至此我们完成了一个这样最简单的神经网络 来完成了线性的预测

    上面的代码我们建立了一个这样的神经网络 并且使用带有噪声的数据 使用梯度下降法找到最优的weight和bias 建立了线性模型

    类似于下图完成的分类 更加直观 

     

     

    下面我们再添加一个隐藏层

     

     

    import tensorflow as tf
    import numpy as np
    
    inputX = np.random.rand(3000,1)
    noise = np.random.normal(0 , 0.05 , inputX.shape)
    outputY = inputX * 4 + 1 + noise
    
    #构建第一层
    #weight1 和 bias1是隐藏层的变量 这个变量在后续的图的计算过程中需要根据误差算法不断的重新赋值
    weight1 = tf.Variable(np.random.rand(inputX.shape[1],4))#服从“0~1”均匀分布的随机样本值。随机样本取值范围是[0,1),不包括1
    bias1 = tf.Variable(np.random.rand(inputX.shape[1],4))#.shape【1】每个维度有几个数据 【0】是有几个维度
    x1 = tf.placeholder(tf.float64 , [None , 1])#x1的shape是列是1,行不定
    y1_ = tf.matmul(x1 , weight1) + bias1
    
    #构建第二层
    weight2 = tf.Variable(np.random.rand(4,1))#由于和y1_矩阵相乘 所有未4*1矩阵
    bias2 = tf.Variable(np.random.rand(inputX.shape[1],1))
    y2_ = tf.matmul(y1_ , weight2) + bias2
    
    y = tf.placeholder(tf.float64 , [None , 1])
    loss = tf.reduce_mean(tf.reduce_sum(tf.square((y2_ - y)) , reduction_indices = [1]))
    #tf.reduce_mean计算张量tensor沿着指定的数轴(tensor的某一维度)上的的平均值损失函数 reduce_sum( ) 是求和函数 使用的是最小二乘法 reduction_indices表示在第一个维度
    train = tf.train.GradientDescentOptimizer(0.25).minimize(loss) #选择梯度下降法训练
    
    init = tf.global_variables_initializer()#初始化模型的参数
    sess = tf.Session()
    sess.run(init)
    
    #开始训练
    for i in range(1000):
        sess.run(train , feed_dict = {x1 : inputX , y : outputY})
    
    #打印weight 和 bias 这个模型最重要的参数    
    print(weight1.eval(sess))
    print('--------------------------')
    print(weight2.eval(sess))
    print('--------------------------')
    print(bias1.eval(sess))
    print('--------------------------')
    print(bias2.eval(sess))
    print('--------------------------resul-------------------------')
    
    x_data = np.matrix([[1] , [2] , [3]])#将1 2 3 当做测试数据看输出数据
    print(sess.run(y2_,feed_dict = {x1 : x_data}))

                

    展开全文
  • 4.用统计学习方法来理解线性回归损失函数和优化方法 5.Sklearn API接口与使用方式 波士顿房价预测案例 参考文档 1.线性回归 线性回归属于监督学习的回归问题的一类,由于回归问题的目标值是连续的,所以线性...

    目录

    1.线性回归

    一元线性关系

    多元线性关系

    2.损失:评估预测结果与真实值的偏差程度

    误差累积的结果

    总损失计算公式:

    损失函数:最小二乘法

    3.损失函数的优化方法

    4.用统计学习方法来理解线性回归、损失函数和优化方法

    5.Sklearn API接口与使用方式

    波士顿房价预测案例

    参考文档


    1.线性回归

    回归(Regression)是另一类重要的监督学习算法。与分类问题不同的是,在回归问题中,其目标是通过对训练样本的学
    习,得到从样本特征到样本标签之间的映射,其中,在回归问题中,样本标签是连续值。典型的回归问题有:①根据人的身
    高、性别和体重等信息预测其鞋子的大小;②根据房屋的面积、卧室的数量预估房屋的价格;③根据博文的历史阅读数量预测
    该用户的博文阅读数等。
    线性回归(Linear Regression)是一类重要的回归问题。在线性回归中,目标值与特征之间存在线性相关的关系。

     

    线性回归的定义:线性回归是一种通过自变量(一个或多个特征值)与因变量(目标值)之间的关系来进行建模的回归分析。

    线性回归根据变量的数量可分为两种回归:

    • 一元线性回归,涉及到的变量只有一个
    • 多元线性回归:涉及到的变量在两个或两个之上

    一元线性关系

    典型的例子是预测房屋价格,假设我们的房屋价格作为目标值,特征为房子面积,通过分析房子面积与房子价格,可得到一种线性关系,我们将这种关系定义为:

    • w的符号决定线是上升还是下降,w值决定上升或下降的快慢。
    • b为偏置,为了使线性模型更加通用

     

    多元线性关系

    一个通过特征的的线性组合来进行预测的函数

    通用公式:

    θ1和x1可看做一个样本,样本下有n个特征,θ0-θn为每个特征的权重,θ与x的乘积为一个样本的目标值

    如有一组x1={1 2 3 4}  

    一组θ1={1

                   2

                   3

                  4} 

    根据矩阵乘法,有:

    目标值=θ1*x1=1*1+2*2+3*3+4*4=30

     

    2.损失:评估预测结果与真实值的偏差程度

    看到一元线性关系,假设红圈所示为预测样本的真实值,箭头所示指向的直线上的一点为预测值,此时真实值与预测值存在偏差,称为损失。

    以下是多元函数的损失情况:

     

    误差累积的结果

    以一元线性关系为例,我们知道,过两点确定一条直线

    那么过三点呢,仅当第三点恰好满足直线方程时,它才可能在直线上。当第三点不在直线上时,就会存在偏差,假设黑点所在为真实值,红点所在为预测值,它们之间的差值就是损失

    当这样的点增多后,虽然直线方程被不断拟合,但任有部分点在线外,随着点的数量不断增多,误差不断累积扩大,当计算完所有点的误差后,我们可以对当前线性回归的结果做一个评估,误差和越小,线性回归的结果就越好。

    总损失计算公式:

    • 设yi为第i个训练样本的真实值
    • hw(xi)为第i个训练样本特征值组合预测函数

     

    损失函数:最小二乘法

    计算完总损失后,可进一步求出总损失的平均值。求平均值的意义在与:当样本数不同的两个训练集进行对比时,总损失无法准确评估(样本数有差异),此时需要对总损失求平均值,该方法又称为最小二乘法。

     

     

     

    3.损失函数的优化方法

    看到这里稍微梳理一下:由于回归是一种不断迭代的算法,通过不断的训练数据进行迭代优化,而优化的目的就是降低损失,使损失函数的值尽可能小,而试图降低损失的过程,就是一个优化过程,下面是两只常用的优化方法.

    优化方法1:正规方程

    正规方程实际上是对最小二乘法进行方程式推导得出的结果,其目的在于求最小θ,解算出最终方程后,带值进行运算(只需要一次运算),最终公式为(具体的推导式见文章最下方):

    这里写图片描述

    • X^T为X的转置矩阵
    • X^-1为矩阵的逆
    • Y为目标值

    正规方程的的缺点在于:需要计算如果特征数量n较大则运算代价大,因为矩阵逆的计算时间复杂度为  ,通常来说当n小于10000 时还是可以接受的。

     

    优化方法2:梯度下降

    我们以单变量(特征值为1)的例子来例假梯度下降的过程,假设有w1,w0两个变量,其中,w0和w1分别为 

    其中α被称作为学习率或者步长,意味着我们可以通过α来控制每一步走的距离, 表示下降方向,沿着这个函数向下找,最后就能找到最低点,而这个最低点,就是损失函数的最小值

     梯度下降和正规方法的对比:

     

    4.用统计学习方法来理解线性回归、损失函数和优化方法

    用统计学习方法来总结上文,首先我们需要明确算法,这里使用的是线性回归算法,线性回归算法需要不断迭代来优化线性方程,而评估优化结果的策略就是求解损失函数的最小值,如何求得最小值就是在求优化的过程,优化方法又分为正规方程(直接求解)和梯度下降(分步求解)。所以,统计学习方法的基本要素分为:算法,策略和优化过程。

    算法 策略(损失函数) 优化
    线性回归 最小二乘法 正规方程/梯度下降

     

    5.Sklearn API接口与使用方式

    使用sklearn的优点是函数封装好,建立模型简单,易使用。但是算法的过程和参数都在算法API内部被固化,想要调参或优化算法需要改源码

    推荐一个进阶工具:tensorflow,tensorflow需自行定义算法,数据处理过程,提供了很大的自由度

     

    正规方程

    from sklearn.linear_model import LinearRegression

    梯度下降

    from sklearn.linear_model import SGDRegressor

     

    波士顿房价预测案例

    该实例的特征为

    分析流程

    • 1.获取波士顿地区房价数据
    • 2. 对数据进行分割,训练集与测试集
    • 3.对训练集与测试集做标准化处理,消除异常值影响
    • 4.使用正规方程LinearRegression或梯度下降SGDRegressor对房价进行预测

    程序

    from sklearn.linear_model import LinearRegression,SGDRegressor
    from sklearn.datasets import load_boston
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.metrics import mean_squared_error
    
    def fun():
        #获取数据
        boston=load_boston()
    
        #分隔数据集合训练集
        x_train,x_test,y_train,y_test=train_test_split(boston.data,boston.target,test_size=0.25)
    
        #对特征值和目标值进行标准化处理
        #目的:消除异常值影响
        std=StandardScaler()
    
        #特征值
        x_train=std.fit_transform(x_train)
        x_test=std.transform(x_test)
    
        #目标值,不能共用一个预估器,所以需要另外实例化
        std_y=StandardScaler()
        #特别注意:由于这里的目标值是一维数组sklearn 0.19版本以上的预估器仅支持二维数组的输入格式,所以需要对一维数组转二维数组
        #由于不知道目标值的个数,所以填-1,目标值对于每个样本只有一个,所以填1列
        y_train=std_y.fit_transform(y_train.reshape(-1,1))
        y_test=std_y.transform(y_test.reshape(-1,1))
    
        #正规方程求解
        lr=LinearRegression()
        lr.fit(x_train,y_train)
    
        #打印权重参数,可以看到每个特征的权重值
        # print("权重结果:",lr.coef_)
    
        #打印预测结果,注意需要反标准化
        y_predict=std_y.inverse_transform(lr.predict(x_test))
        # print("对于测试集的预测结果:",y_predict)
    
        #打印均方误差
        print("正规方程均方误差值::", mean_squared_error(std_y.inverse_transform(y_test),y_predict))
    
        #梯度下降求解
        sgd=SGDRegressor()
        sgd.fit(x_train,y_train)
    
        # 打印权重参数,可以看到每个特征的权重值
        # print("权重结果:",sgd.coef_)
    
        # 打印预测结果,注意需要反标准化
        y_sgd_predict = std_y.inverse_transform(sgd.predict(x_test))
        # print("对于测试集的预测结果:",y_predict)
    
        # 打印均方误差
        print("梯度下降均方误差值::", mean_squared_error(std_y.inverse_transform(y_test), y_sgd_predict))
    
    if __name__=="__main__":
        fun()
    
    
    

    输出结果(每一次执行的结果不一定相同,主要原因是在做数据分隔使每次的训练集测试集分到的样本不同导致):

    补充: 

    1.回归性能评估

    使用均方误差MSE(Mean Squared Error)评价机制进行回归性能评估。MSE是真实值与预测值的差值的平方然后求和平均。

    公式:

    sklearn接口:

    from sklearn.metrics import mean_squared_error 

     范围[0,+∞),当预测值与真实值完全相同时为0,误差越大,该值越大。

    import numpy as np
    from sklearn import metrics
    y_true = np.array([1.0, 5.0, 4.0, 3.0, 2.0, 5.0, -3.0])
    y_pred = np.array([1.0, 4.5, 3.5, 5.0, 8.0, 4.5, 1.0])
    print(metrics.mean_squared_error(y_true, y_pred)) # 8.107142857142858

    2.梯度下降学习率

    sklearn设置了默认的超参数,可在实例化时修改

    sgd=SGDRegressor(alpha=)

     

    参考文档

    正规方程 https://baike.baidu.com/item/%E6%AD%A3%E8%A7%84%E6%96%B9%E7%A8%8B/10001812 

    正规方程推到from吴恩达 https://blog.csdn.net/melon__/article/details/80589759

    梯度下降算法原理讲解 https://blog.csdn.net/qq_41800366/article/details/86583789 

    什么是梯度下降 https://www.zhihu.com/question/305638940/answer/670034343

    sklearn 和tensorflow的区别 https://blog.csdn.net/youhuakongzhi/article/details/94208335

    展开全文
  • 这篇笔记将会探究在机器学习的线性回归如何求解损失函数。 \(Ax=b\) 无解时求近似解 今天我们需要求一个线性方程组,长成这样 \[ \begin{equation} \left \{ \begin{array}{lr} 2 * w_1 + 2 * w_2 + b = 14 \\ ...
  • 没有约束条件,目标函数是若干二次项的和,每一项的形式如aTix−biaiTx−bia_i^Tx - b_i,具体形式如下: minimizef(x)=∑i=1k(aTix−bi)2minimizef(x)=∑i=1k(aiTx−bi)2 minimize \quad f(x) = \sum_{i=1}^{k}(a_...
  • 然而,将均方差作为损失函数是通过推导得到的。 首先,线性回归属于普通线性模型,而普通线性回归中的误差项满足下面四个假设: 零均值假设:误差项是期望为零的随机变量,即E(e)=0E(e)=0E(e)=0 不变方差假设:误差...
  • 线性回归模型 基本概念 定义:运用一条直线,近似地表示自变量x与因变量y之间的关系 公式:Y = aX + b 如何判断那条直线可以代表x与y之间的关系 如何理解线与散点之间的关系 ...损失函数 根据上面的目...
  • 1 多元线性回归模型
  • 回归 最早由英国科学家弗朗西斯高尔顿提出,生物学家,他发现一个现象,虽然有一个趋势“父母高,儿女也高;...一元线性回归 回归分析:用来建立方程模拟两个或者多个变量之间如何关联。 被预测的变量叫做因变量...
  • 损失函数

    2017-02-17 20:47:00
    监督学习中通常通过对损失函数最优化(最小化)来学习模型。 本文介绍了几种损失函数和正则化项以及正则化对模型的影响。 损失函数 损失函数度量模型一次预测的好坏,风险函数度量评价意义下模型预测的好坏。 模型...
  • 机器学习-02回归模型线性回归评估训练结果误差(metrics)模型的保存和加载岭回归多项式回归决策树基本算法原理 回归模型 线性回归 输入 输出 0.5 5.0 0.6 5.5 0.8 6.0 1.1 6.8 1.4 7.0 ... y = f(x) 预测函数:y ...
  • tensorflow一元二次函数拟合

    千次阅读 2019-01-01 09:59:45
    先看下要做的内容,创建一元二次函数y=x平方-0.5,其中为了更符合散点图模拟需要,在方程加噪点,以标准方差0.05行驶,如图所示 折线图 散点图 下面我们要做的,是要计算机自动拟合出该散点图的函数,画出图样,...
  • 损失函数最终作为模型建立的学习准则和优化问题,通常将损失函数用来判断模型预测出来的结果与实际值的差距程度。 优化函数 优化函数对损失函数进行优化,寻找最优参数。 优化损失函数的方式有很多种,常用到的是...
  • 一元线性回归模型

    2019-12-08 19:42:27
    本文主要介绍线性回归模型,该模型主要应用于监督学习中目标变量是连续数值型的场景。...最简单的线性回归模型就是一元线性回归模型,其模型的形式就是: y=ax+b(1) y=ax+b \tag{1} y=ax+b(1) 由式...
  • 一元线性回归

    2018-09-19 12:14:08
    2.1一元线性回归python代码 2.2sklearn代码 3示例 3.1波士顿房价预测 3.2北京房价预测 1.概览 2代码实现 2.1一元线性回归python代码 # -*- coding: utf-8 -*- """ Created on Wed Sep 19 ...
  • 交叉熵损失函数

    万次阅读 2016-10-05 23:27:35
    交叉熵作为损失函数还有一个好处是使用sigmoid函数在梯度下降时能避免均方误差损失函数学习速率降低的问题,因为学习速率可以被输出的误差所控制。 PS:通常“相对熵”也可称为“交叉熵”,因为真实分布p是固定...
  • 先看下要做的内容,创建一元二次函数y=x平方-0.5,其中为了更符合散点图模拟需要,在方程加噪点,以标准方差0.05行驶,如图所示 折线图 散点图 下面我们要做的,是要计算机自动拟合出该散点图的函数,画出...
  • 回归函数和代价函数

    2020-08-16 11:03:54
    这里将会从一个简单的例子引入话题。例子是一个自变量和一个因变量构成的一元一次函数。因为同时兼顾了有趣和浅显,例子也是相当的乱来。能看懂就好,不要介意这些细节啦。
  • 四、一元线性回归 1. 预测函数 输入 输出 0 1 1 3 2 5 3 7 4 9 … … 预测函数为:y=1+2xy=1+2xy=1+2x 预测:输入10;输出21 y=w0+w1xy=w_0+w_1xy=w0​+w1​x,任务就是寻找预测函数中的...
  • 原函数是一元函数(关于x),它的损失函数是二元函数(关于w和b) 这里介绍两种损失函数:平方损失函数和均方差损失函数 【2】多元线性回归问题 X和W都是m+1维的向量,损失函数是高维空间中的凸函数 【3】学习率 学习...
  • 1、损失函数概念 损失函数:衡量模型输出与真实标签的差异;...损失函数(Loss Function)Loss=f(y^,y)Loss=f(\hat{y},y)Loss=f(y^​,y)这是计算一个样本的损失; 代价函数(Cost Function)cos⁡t=1N∑iNf
  • 1.线性回归 1.1 线性模型 试图学得一个通过属性的线性组合来进行预测的函数: ...1.3 损失函数(误差大小) 如何去求模型当中的W,使得损失最小? (目的是找到最小损失对应的W值) 缺点:当特征过于复杂,求解速
  • 这次就来仔细探究一下一元线性回归的细节(多元线性回归下回讲) 上面公式不难,初中生都知道,代表的是一条在平面上的线。而我们的目标是找出最佳的参数a,b使损失函数尽可能小。上篇文章说了什么是损失函数,这里...
  • 线性回归作为监督学习中经典的回归模型之一,是初学者入门非常好的开始。宏观上考虑理解性的概念,我想我们在初中可能就接触过,y=ax,x为自变量,y为因变量,a为系数也是斜率。如果我们知道了a系数,那么给我一个x...
  • 【学习笔记】Pytorch深度学习—损失函数损失函数概念交叉熵损失函数其他损失函数NLL、BCE、BCEWithLogits Loss 前面学习了如何构建模型、模型初始化,本章学习损失函数。本章从3个方面学习,(1)损失函数的概念以及...
  • *-coding:utf-8-*-import numpy as npimport matplotlib.pyplot as plt2、定义线性回归模型def predict(x, a, b):y_predict = a * x + breturn y_predict一元线性回归的模型如下:公式1—一元线性回归模型损失函数为...
  • pytorch 一元线形回归

    2019-04-14 16:48:30
    今天做的是一个用pytorch训练出来的一元线形回归模型;如图,我们先找一些样本点,用 matplotlib.pyplot显示如上,我们把它加载到内存里面,然后通过pytorch的模组简单自定义一下前向函数就可以了,完整代码如下 ...
  • 这篇博客将主要针对西瓜书3.1和3.2节(一元线性回归)的内容进行补充。主要有如何判断出一元线性回归损失函数是一个凸函数以及如何将w值向量化表示。

空空如也

空空如也

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

一元回归损失函数计算