精华内容
下载资源
问答
  • 多变量梯度下降算法
    千次阅读
    2018-07-14 11:25:18

    这是机器学习的第一章第三节:Gradient descent for Multiple variables(多变量的梯度下降法)

    在学习本节过程中,将会涉及到高等数学中矩阵的相关知识

    通过这一节的学习将会了解:

    一、第一节中函数1.1.1,函数1.1.2和第二节中公式1.2.1在多个自变量\(x\)与多个parameter \(\theta_i\)的情况下的具体计算方法;

    二、Feature Scaling(特征缩放) 和 Mean normalization(均值归一化) 的相关使用知识。


    一、首先解释\(x_j^{(i)},y_j^{(i)},\theta_j\)(此时我们不再使用\(x_i,y_i\),因为这时将会出现歧义)角标的含义,我们将其称为索引(index)。

    我们还记得\(x\)表示的是自变量特征(features),那么:

    superscript \((i)\)相当于第\(i\)组数据(包含一条数据,所有特征。如果training set只有1组数据,那么此时将略去\(i\)不做讨论)

    subscript \(j\)相当于第\(j\)组特征(包含一组特征中的所有数据。如果只有1组特征,那么此时将略去\(j\)不做讨论)

    对于一般情况,通常存在\(m\)组数据,\(n\)个特征。我们可以通过下图进一步理解:


    对于上图所示的数据组,不难发现一共有\(4\)个特征,此时由上述描述,可得:

    \( x^{(2)}=\begin{bmatrix}1416\\3\\2\\40\end{bmatrix}\),\(x_3^{(2)}=2\)。

    因此,我们可以将features(特征\(x\)) 和parameters(参数\(\theta\))均用矩阵的形式表示如下:

    \(x = \begin{bmatrix} x_0\\  x_1\\  \vdots\\  x_n\end{bmatrix},\;\theta = \begin{bmatrix} \theta_0\\  \theta_1\\  \vdots\\  \theta_n\end{bmatrix}\),(对于\(x_0 = 1\)将在接下来的讨论中进行解释)

    接下来我们对下面对三个函数公式进行分别讨论:

    我们将函数1.1.1添加至\(n\)个特征,\(n+1\)个参数,结果如下:\(h_\theta(x) = \theta_0 + \theta_1x_1+\theta_2x_2+\cdots +\theta_n x_n\)

    同时引入一个常数\(x_0^{(i)} = 1\)(带有角标\((i)\)表示对于任意一组数据,其\(x_0=1\)均成立)函数1.1.1将变为:

    \(h_\theta(x) = \theta_0x_0 + \theta_1x_1+\theta_2x_2+\cdots +\theta_n x_n\),由于\(x_0^{(i)} = 1\),将不影响函数计算结果。

    此时根据矩阵运算,我们又可以将函数1.1.1写成如下形式:

    \(h_\theta(x) = \begin{bmatrix} \theta_0 \ \theta_1\  \cdots\  \theta_n\end{bmatrix}\begin{bmatrix} x_0\\  x_1\\  \vdots\\  x_n\end{bmatrix} = \theta^Tx\)

    此时我们可以认真对等式进行理解。同时需要注意,此时的features和parameters均有\(n+1\)项数据,表示为:

     \(x\in \mathbb{R}^{n+1}\;,\;\theta \in \mathbb{R}^{n+1}\)

    同样对于函数1.1.2,由于parameters共有\(n+1\)个,因此将变为:

     \(\displaystyle J(\theta_0,\theta_1,\cdot,\theta_n)=\frac{1}{2m}\sum_{i=1}^{m}(h_\theta(x_i)-y_i)^2\)

    将\((\theta_0,\theta_1,\cdot,\theta_n)\)用矩阵表示,又可将函数1.1.2写成如下形式:

    \(\displaystyle J(\theta)=\frac{1}{2m}\sum_{i=1}^{m}(h_\theta(x_i)-y_i)^2\)

    接下来讨论公式1.2.1,其将变为:

    \(\displaystyle \theta_j := \theta_j - \alpha\frac{\partial }{\partial \theta_j}J(\theta_0,\theta_1,\cdots,\theta_n)\)    \(j = 0,\cdots,n\)

    将\((\theta_0,\theta_1,\cdots,\theta_n)\)用矩阵表示,也就是:

    \(\displaystyle \theta_j := \theta_j - \alpha\frac{\partial }{\partial \theta_j}J(\theta)\)    (simultaneously update for every\(j = 0,\cdots,n\))

    还记得当\(n=1\)时,我们需要同时更新\(\theta_0,\theta_1\),计算形式如下:


    可以发现,对于\(\theta_1\)的更新,其最后一项就是\(x_1^{(i)}\),因此对于\(n>1\)的情况,其计算形式如下:


    对应示例如下:



    二、使用 Feature scaling(特征缩放) 和 Mean normalization(均值归一化) 这两个方法能够高效的进行梯度下降计算,从而降低计算\(min\,J(\theta)\)所需的循环次数,从而提高算法效率。

    Feature scaling在课件中有如下描述:


    Mean normalization在课件中这样描述:


    如图片所示,Feature Scaling的要点在于将特征\(x_j\)缩放为一个在\(0\)到\(1\)之间的值,其具体计算方法是,对于\(x_j\),若其范围是\(x_j\in (a,b)\),则将\(x_j\)变为\(\frac{x_j}{b-a}\)(若范围值离散,如只能取整数,则分母为范围数)

    Mean normalization即是在Feature scaling的基础上,进一步将分子中的\(x_j\)减去其在training set(共\(m\)组数据)中的平均值,从而使整体的结果的均值更趋于\(0\)。

    结合这两个方法,我们可以写出对于\(x_i\)的定义式,形式如下:

    \(x_j^{(i)} := \frac{x_j^{(i)} - \mu_i}{s_i}\)

    其中,\(\mu_i\)表示\(x_j^{(i)}\)的平均值,计算如下:\(\displaystyle \mu_i = \frac{1}{m}\sum_{i=1}^{m}x_j^{(i)}\)

    \(s_i\)表示特征值的范围,计算如下:\(s_i = (max-min)\)

    举一个简单的例子来说,如果\(x_1^{(i)}\)代表房价,且其范围\(x_1^{(i)} \in (100,2000)\),房价平均值为\(1000\),那么改进后的\(x_1^{(i)}\)表示如下:

    \(x_1^{(i)} := \frac{x_1^{(i)} - \mu_i}{s_i}\)

    end~

    更多相关内容
  • 也称为柯西(Cauchy)方法,使用此算法,我们将从对最陡峭梯度的连续求值中找到多元函数的最佳点(出于代码的目的,仅两个变量x,y)。
  • 2.3 代价函数的直观理解I 让我们通过一些例子来获取一些直观的感受,看看代价函数到底是在干什么。 2.4 代价函数的直观理解II ...代价函数的样子类似于等高线图,则可以看出在三维空间...梯度下降是一个用来求函数最

    2.3 代价函数的直观理解I

    让我们通过一些例子来获取一些直观的感受,看看代价函数到底是在干什么。


    2.4 代价函数的直观理解II

    代价函数的样子类似于等高线图,则可以看出在三维空间中存在一个J(θ0,θ1)使得最小的点。

    通过这些图形,我希望你能更好地理解这些代价函数J所表达的值是什么样的,它们对应的假设是什么样的,以及什么样的假设对应的点,更接近于代价函数的最小值。

    我们将介绍梯度,能够自动地找出能使代价函数最小化的参数和的值。


    2.5 梯度下降

    梯度下降是一个用来求函数最小值的算法,我们将使用梯度下降算法来求出代价函数J(θ0,θ1)的最小值。

    梯度下降背后的思想是:开始时我们随机选择一个参数(θ0,θ1,~~~,θn)的组合,计算代价函数,然后我们寻找下一个能让代价函数值下降最多的参数组合。我们持续这么做直到到到一个局部最小值(local minimum),因为我们并没有尝试完所有的参数组合,所以不能确定我们得到的局部最小值是否便是全局最小值(global minimum),选择不同的初始参数组合,可能会找到不同的局部最小值。

    想象一下你正站立在山的这一点上,站立在你想象的公园这座红色山上,在梯度下降算法中,我们要做的就是旋转360度,看看我们的周围,并问自己要在某个方向上,用小碎步尽快下山。这些小碎步需要朝什么方向?如果我们站在山坡上的这一点,你看一下周围,你会发现最佳的下山方向,你再看看周围,然后再一次想想,我应该从什么方向迈着小碎步下山?然后你按照自己的判断又迈出一步,重复上面的步骤,从这个新的点,你环顾四周,并决定从什么方向将会最快下山,然后又迈进了一小步,并依此类推,直到你接近局部最低点的位置。

    批量梯度下降(batch gradient descent)算法的公式为:

    其中是学习率(learning rate),它决定了我们沿着能让代价函数下降程度最大的方向向下迈出的步子有多大,在批量梯度下降中,我们每一次都同时让所有的参数减去学习速率乘以代价函数的导数。

    在梯度下降算法中,还有一个更微妙的问题,梯度下降中,我们要更新和 θ0,θ1,当j=0和j=1时,会产生更新,所以你将更新j(θ0)和J(θ1)。实现梯度下降算法的微妙之处是,在这个表达式中,如果你要更新这个等式,你需要同时更新θ0和θ1,我的意思是在这个等式中,我们要这样更新:

    θ0:=θ0  ,并更新θ1:= θ1。

    实现方法是:你应该计算公式右边的部分,通过那一部分计算出和的值,然后同时更新θ0和θ1。

    让我进一步阐述这个过程:

    当人们谈到梯度下降时,他们的意思就是同步更新。

    在接下来的视频中,我们要进入这个微分项的细节之中。我已经写了出来但没有真正定义,如果你已经修过微积分课程,如果你熟悉偏导数和导数,这其实就是这个微分项:


    2.6 梯度下降的直观理解

    梯度下降算法如下:

    描述:对赋值,使得按梯度下降最快方向进行,一直迭代下去,最终得到局部最小值。其中是学习率(learning rate),它决定沿着能让代价函数下降程度最大的方向向下迈出的步子有多大。

    对于这个问题,求导的目的,基本上可以说取这个红点的切线,就是这样一条红色的直线,刚好与函数相切于这一点,这条直线的斜率正好是这个三角形的高度除以这个水平长度,现在,这条线有一个正斜率,也就是说它有正导数,因此,我得到的新的θ1,θ1更新后等于θ1)减去一个正数乘以learning rate。

    这就是梯度下降法的更新规则:

     让我们来看看如果learning rate太小或太大会出现什么情况:

    如果learning rate太小了,可能会很慢,因为它会一点点挪动,它会需要很多步才能到达全局最低点。

    如果learning rate太大,那么梯度下降法可能会越过最低点,甚至可能无法收敛,下一次迭代又移动了一大步,越过一次,又越过一次,一次次越过最低点,直到你发现实际上离最低点越来越远,所以,如果太大,它会导致无法收敛,甚至发散。

    因此,如果你的参数已经处于局部最低点,结果是局部最优点的导数将等于零,因为它是那条切线的斜率。那么梯度下降法更新其实什么都没做,它不会改变参数的值。它使得不再改变,也就是新的等于原来的,这也解释了为什么即使学习速率保持不变时,梯度下降也可以收敛到局部最低点。

    我们来看一个例子,这是代价函数。

    我想找到它的最小值,首先初始化我的梯度下降算法,在那个品红色的点初始化,如果我更新一步梯度下降,也许它会带我到这个点,因为这个点的导数是相当陡的。现在,在这个绿色的点,如果我再更新一步,你会发现我的导数,也即斜率,是没那么陡的。随着我接近最低点,我的导数越来越接近零,所以,梯度下降一步后,新的导数会变小一点点。然后我想再梯度下降一步,在这个绿点,我自然会用一个稍微跟刚才在那个品红点时比,再小一点的一步,到了新的红色点,更接近全局最低点了,因此这点的导数会比在绿点时更小。所以,我再进行一步梯度下降时,我的导数项是更小的,θ1更新的幅度就会更小。所以随着梯度下降法的运行,你移动的幅度会自动变得越来越小,直到最终移动幅度非常小,你会发现,已经收敛到局部极小值。

    回顾一下,在梯度下降法中,当我们接近局部最低点时,梯度下降法会自动采取更小的幅度,这是因为当我们接近局部最低点时,很显然在局部最低时导数等于零,所以当我们接近局部最低时,导数值会自动变得越来越小,所以梯度下降将自动采取较小的幅度,这就是梯度下降的做法。所以实际上没有必要再另外减小。


    2.7 梯度下降的线性回归

    在以前的视频中我们谈到关于梯度下降算法,梯度下降是很常用的算法,它不仅被用在线性回归上和线性回归模型、平方误差代价函数。在这段视频中,我们要将梯度下降和代价函数结合。我们将用到此算法,并将其应用于具体的拟合直线的线性回归算法里。

    梯度下降算法和线性回归算法比较如图:

    对我们之前的线性回归问题运用梯度下降法,关键在于求出代价函数的导数,即:

    则算法改写成:

    我们刚刚使用的算法,有时也称为”批量梯度下降”,指的是在梯度下降的每一步中,我们都用到了所有的训练样本,在梯度下降中,在计算微分求导项时,我们需要进行求和运算,所以,在每一个单独的梯度下降中,我们最终都要计算这样一个东西,这个项需要对所有个训练样本求和。


    批量梯度算法代码与设计:

    import matplotlib.pyplot as plt
    
    x_data=[1.0,2.0,3.0]
    y_data=[2.0,4.0,6.0]
    
    m=len(x_data)
    # 默认w的权值,随着梯度下降而修正
    w=1.0
    #学习率
    learning_rate=0.01
    
    def forward(x):
        return x*w
    
    def cost(x_data,y_data):
        cost=0.0
        total_cost=0
        for x,y in zip(x_data,y_data):
            y_test=forward(x)
            cost=(y_test-y)*(y_test-y)
            total_cost=total_cost+cost
        return total_cost/m
    
    # 计算新的w的修正
    def gradiedent(x_data,y_data):
        grad=0.0
        for x,y in zip(x_data,y_data):
            grad=grad+2*x*(x*w-y)
        return grad
    epoch_list=[]
    cost_list=[]
    
    print("训练前",4,forward(4))
    for epoch in range(100):
        y_cost=cost(x_data,y_data)
        # 在当前w权重下计算,w的修正值
        grad_val=gradiedent(x_data,y_data)
        w = w - learning_rate * grad_val
        print("轮次:",epoch,"w=",w,"loss",y_cost)
        epoch_list.append(epoch)
        cost_list.append(y_cost)
    print("训练后",4,forward(4))
    
    #绘制损失loss与权重w之间的函数图像
    plt.plot(epoch_list,cost_list)
    plt.ylabel('Loss')
    plt.xlabel('w')
    plt.show()

    结果:

     


    随机梯度算法代码与设计:

    import matplotlib.pyplot as plt
    
    # 随机梯度下降法和梯度下降法的主要区别在于:
    # 1、损失函数由cost()更改为loss()。cost是计算所有训练数据的损失,loss是计算一个训练函数的损失。
    # 对应于源代码则是少了两个for循环。
    # 2、梯度函数gradient()由计算所有训练数据的梯度更改为计算一个训练数据的梯度。
    # 3、本算法中的随机梯度主要是指,每次拿一个训练数据来训练,然后更新梯度参数。
    # 本算法中梯度总共更新100(epoch)x3 = 300次。梯度下降法中梯度总共更新100(epoch)次。
    
    x_data=[1.0,2.0,3.0]
    y_data=[2.0,4.0,6.0]
    
    m=len(x_data)
    # 默认w的权值,随着梯度下降而修正
    w=1.0
    #学习率
    learning_rate=0.01
    
    def forward(x):
        return x * w
    
    # 随机梯度算法
    def loss(x_val,y_val):
        y_cost= forward(x_val)
        return (y_cost-y_val)*(y_cost-y_val)
    
    def gradiedent(x,y):
        return 2 * x*(forward(x) - y)
    
    epoch_list=[]
    loss_list=[]
    
    print("训练前",4,forward(4))
    
    for epoch in range(100):
        for x,y in zip(x_data,y_data):
            grad=gradiedent(x,y)
            w=w-learning_rate*grad
            print("x:",x,"y",y,"grad",grad)
            l=loss(x,y)
            # 疑问此处仅选择最后一次并没有达到随机的效果????
            print( "loss", l)
        print("进程轮数:",epoch,"w=",w,"loss",l)
        epoch_list.append(epoch)
        loss_list.append(l)
    
    print("训练后",4,forward(4))
    # 绘制epoch_list与loss_list的图像
    plt.plot(epoch_list,loss_list)
    plt.ylabel('Loss')
    plt.xlabel('epoch_list')
    plt.show()

    结果:

     

    展开全文
  • 使用matlab实现的,基础单变量以及多变量梯度下降算法,和信号分类以及信号归一化部分算法,是机器学习领域最基本的代码,希望大家多多交流
  • 主要为大家详细介绍了python使用梯度下降算法实现一个线性回归,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 梯度下降算法原理讲解——机器学习

    万次阅读 多人点赞 2019-01-21 20:27:48
    详细来讲讲梯度下降算法的原理,感受数学和程序的魅力吧!!

    1. 概述

    梯度下降(gradient descent)在机器学习中应用十分的广泛,不论是在线性回归还是Logistic回归中,它的主要目的是通过迭代找到目标函数的最小值,或者收敛到最小值。
    本文将从一个下山的场景开始,先提出梯度下降算法的基本思想,进而从数学上解释梯度下降算法的原理,解释为什么要用梯度,最后实现一个简单的梯度下降算法的实例!

    2. 梯度下降算法

    2.1 场景假设

    梯度下降法的基本思想可以类比为一个下山的过程。
    假设这样一个场景:一个人被困在山上,需要从山上下来(找到山的最低点,也就是山谷)。但此时山上的浓雾很大,导致可视度很低;因此,下山的路径就无法确定,必须利用自己周围的信息一步一步地找到下山的路。这个时候,便可利用梯度下降算法来帮助自己下山。怎么做呢,首先以他当前的所处的位置为基准,寻找这个位置最陡峭的地方,然后朝着下降方向走一步,然后又继续以当前位置为基准,再找最陡峭的地方,再走直到最后到达最低处;同理上山也是如此,只是这时候就变成梯度上升算法了
    在这里插入图片描述

    2.2 梯度下降

    梯度下降的基本过程就和下山的场景很类似。

    首先,我们有一个可微分的函数。这个函数就代表着一座山。我们的目标就是找到这个函数的最小值,也就是山底。根据之前的场景假设,最快的下山的方式就是找到当前位置最陡峭的方向,然后沿着此方向向下走,对应到函数中,就是找到给定点的梯度 ,然后朝着梯度相反的方向,就能让函数值下降的最快!因为梯度的方向就是函数之变化最快的方向(在后面会详细解释)
    所以,我们重复利用这个方法,反复求取梯度,最后就能到达局部的最小值,这就类似于我们下山的过程。而求取梯度就确定了最陡峭的方向,也就是场景中测量方向的手段。那么为什么梯度的方向就是最陡峭的方向呢?接下来,我们从微分开始讲起:

    2.2.1 微分

    看待微分的意义,可以有不同的角度,最常用的两种是:

    • 函数图像中,某点的切线的斜率
    • 函数的变化率
      几个微分的例子:

    1.单变量的微分,函数只有一个变量时

    d ( x 2 ) d x = 2 x \frac{d(x^2)}{dx}=2x dxd(x2)=2x

    d ( − 2 y 5 ) d y = − 10 y 4 \frac{d(-2y^5)}{dy}=-10y^4 dyd(2y5)=10y4

    d ( 5 − θ ) 2 d θ = − 2 ( 5 − θ ) \frac{d(5-\theta )^2}{d\theta}=-2(5-\theta) dθd(5θ)2=2(5θ)

    2.多变量的微分,当函数有多个变量的时候,即分别对每个变量进行求微分

    ∂ ∂ x ( x 2 y 2 ) = 2 x y 2 \frac{\partial}{\partial x}(x^2y^2) = 2xy^2 x(x2y2)=2xy2

    ∂ ∂ y ( − 2 y 5 + z 2 ) = − 10 y 4 \frac{\partial}{\partial y}(-2y^5+z^2) = -10y^4 y(2y5+z2)=10y4

    ∂ ∂ θ 2 ( 5 θ 1 + 2 θ 2 − 12 θ 3 ) = 2 \frac{\partial}{\partial \theta_{2}}(5\theta_{1} + 2\theta_{2} - 12\theta_{3}) = 2 θ2(5θ1+2θ212θ3)=2

    ∂ ∂ θ 2 ( 0.55 − ( 5 θ 1 + 2 θ 2 − 12 θ 3 ) ) = − 2 \frac{\partial}{\partial \theta_{2}}(0.55 - (5\theta_{1} + 2\theta_{2} - 12\theta_{3})) = -2 θ2(0.55(5θ1+2θ212θ3))=2

    2.2.2 梯度

    梯度实际上就是多变量微分的一般化。
    下面这个例子:

    J ( Θ ) = 0.55 − ( 5 θ 1 + 2 θ 2 − 12 θ 3 ) J(\Theta ) = 0.55 - (5\theta_{1} + 2\theta_{2} - 12\theta_{3}) J(Θ)=0.55(5θ1+2θ212θ3)

    ▽ J ( Θ ) = < ∂ J ∂ θ 1 , ∂ J ∂ θ 2 , ∂ J ∂ θ 3 > = ( − 5 , − 2 , 12 ) \triangledown J(\Theta ) = \left < \frac{\partial J}{\partial \theta_{1}}, \frac{\partial J}{\partial \theta_{2}},\frac{\partial J}{\partial \theta_{3}} \right > =(-5,-2,12) J(Θ)=θ1J,θ2J,θ3J=(5,2,12)

    我们可以看到,梯度就是分别对每个变量进行微分,然后用逗号分割开,梯度是用<>包括起来,说明梯度其实一个向量。

    梯度是微积分中一个很重要的概念,之前提到过梯度的意义

    • 在单变量的函数中,梯度其实就是函数的微分,代表着函数在某个给定点的切线的斜率
    • 在多变量函数中,梯度是一个向量,向量有方向,梯度的方向就指出了函数在给定点的上升最快的方向

    这也就说明了为什么我们需要千方百计的求取梯度!我们需要到达山底,就需要在每一步观测到此时最陡峭的地方,梯度就恰巧告诉了我们这个方向。梯度的方向是函数在给定点上升最快的方向,那么梯度的反方向就是函数在给定点下降最快的方向,这正是我们所需要的。所以我们只要沿着梯度的方向一直走,就能走到局部的最低点!

    2.3 数学解释

    首先给出数学公式:

    Θ 1 = Θ 0 + α ▽ J ( Θ ) → e v a l u a t e d a t Θ 0 {\color{Red} \Theta^1} = {\color{Blue} \Theta^0} + {\color{Green} \alpha} {\color{Purple} \triangledown J(\Theta)}\rightarrow evaluated at \Theta^0 Θ1=Θ0+αJ(Θ)evaluatedatΘ0

    此公式的意义是:J是关于Θ的一个函数,我们当前所处的位置为Θ0点,要从这个点走到J的最小值点,也就是山底。首先我们先确定前进的方向,也就是梯度的反向,然后走一段距离的步长,也就是α,走完这个段步长,就到达了Θ1这个点!
    在这里插入图片描述

    2.3.1 α

    α在梯度下降算法中被称作为学习率或者步长,意味着我们可以通过α来控制每一步走的距离,以保证不要步子跨的太大扯着蛋,哈哈,其实就是不要走太快,错过了最低点。同时也要保证不要走的太慢,导致太阳下山了,还没有走到山下。所以α的选择在梯度下降法中往往是很重要的!α不能太大也不能太小,太小的话,可能导致迟迟走不到最低点,太大的话,会导致错过最低点!

    2.3.2 梯度要乘以一个负号

    梯度前加一个负号,就意味着朝着梯度相反的方向前进!我们在前文提到,梯度的方向实际就是函数在此点上升最快的方向!而我们需要朝着下降最快的方向走,自然就是负的梯度的方向,所以此处需要加上负号;那么如果时上坡,也就是梯度上升算法,当然就不需要添加负号了。

    3. 实例

    我们已经基本了解了梯度下降算法的计算过程,那么我们就来看几个梯度下降算法的小实例,首先从单变量的函数开始,然后介绍多变量的函数。

    3.1 单变量函数的梯度下降

    我们假设有一个单变量的函数

    J ( θ ) = θ 2 J(\theta) = \theta^2 J(θ)=θ2

    函数的微分,直接求导就可以得到

    J ′ ( θ ) = 2 θ J'(\theta) = 2\theta J(θ)=2θ

    初始化,也就是起点,起点可以随意的设置,这里设置为1

    θ 0 = 1 \theta^0 = 1 θ0=1

    学习率也可以随意的设置,这里设置为0.4

    α = 0.4 \alpha = 0.4 α=0.4

    根据梯度下降的计算公式

    Θ 1 = Θ 0 + α ▽ J ( Θ ) → e v a l u a t e d a t Θ 0 {\color{Red} \Theta^1} = {\color{Blue} \Theta^0} + {\color{Green} \alpha} {\color{Purple} \triangledown J(\Theta)}\rightarrow evaluated at \Theta^0 Θ1=Θ0+αJ(Θ)evaluatedatΘ0

    我们开始进行梯度下降的迭代计算过程:

    θ 0 = 1 \theta^0 = 1 θ0=1

    θ 1 = θ 0 − α ∗ J ′ ( θ 0 ) = 1 − 0.4 ∗ 2 = 0.2 \theta^1 = \theta^0 - \alpha*J'(\theta^0)=1 - 0.4*2 = 0.2 θ1=θ0αJ(θ0)=10.42=0.2

    θ 2 = θ 1 − α ∗ J ′ ( θ 1 ) = 0.2 − 0.4 ∗ 0.4 = 0.04 \theta^2 = \theta^1 - \alpha*J'(\theta^1)= 0.2 - 0.4*0.4=0.04 θ2=θ1αJ(θ1)=0.20.40.4=0.04

    θ 3 = 0.008 \theta^3 = 0.008 θ3=0.008

    θ 4 = 0.0016 \theta^4 = 0.0016 θ4=0.0016

    如图,经过四次的运算,也就是走了四步,基本就抵达了函数的最低点,也就是山底
    在这里插入图片描述

    3.2 多变量函数的梯度下降

    我们假设有一个目标函数

    J ( Θ ) = θ 1 2 + θ 2 2 J(\Theta) = \theta_{1}^2 + \theta_{2}^2 J(Θ)=θ12+θ22

    现在要通过梯度下降法计算这个函数的最小值。我们通过观察就能发现最小值其实就是 (0,0)点。但是接下来,我们会从梯度下降算法开始一步步计算到这个最小值!
    我们假设初始的起点为:

    Θ 0 = ( 1 , 3 ) \Theta^0 = (1, 3) Θ0=(1,3)

    初始的学习率为:

    α = 0.1 \alpha = 0.1 α=0.1

    函数的梯度为:

    ▽ J ( Θ ) = < 2 θ 1 , 2 θ 2 > \triangledown J(\Theta ) = \left < 2\theta_{1},2\theta_{2} \right > J(Θ)=2θ1,2θ2

    进行多次迭代:

    Θ 0 = ( 1 , 3 ) \Theta^0 = (1, 3) Θ0=(1,3)

    Θ 1 = Θ 0 − α ▽ J ( Θ ) = ( 1 , 3 ) − 0.1 ∗ ( 2 , 6 ) = ( 0.8 , 2.4 ) \Theta^1 = \Theta^0 - \alpha\triangledown J(\Theta ) = (1,3) - 0.1*(2, 6)=(0.8, 2.4) Θ1=Θ0αJ(Θ)=(1,3)0.1(2,6)=(0.8,2.4)

    Θ 2 = ( 0.8 , 2.4 ) − 0.1 ∗ ( 1.6 , 4.8 ) = ( 0.64 , 1.92 ) \Theta^2 = (0.8, 2.4) - 0.1*(1.6, 4.8)=(0.64, 1.92) Θ2=(0.8,2.4)0.1(1.6,4.8)=(0.64,1.92)

    Θ 3 = ( 0.5124 , 1.536 ) \Theta^3 =(0.5124, 1.536) Θ3=(0.5124,1.536)

    Θ 4 = ( 0.4096 , 1.228800000000001 ) \Theta^4 =(0.4096, 1.228800000000001) Θ4=(0.4096,1.228800000000001)
    ⋮ \vdots
    Θ 10 = ( 0.1073741824000003 , 0.32212254720000005 ) \Theta^{10} =(0.1073741824000003, 0.32212254720000005) Θ10=(0.1073741824000003,0.32212254720000005)
    ⋮ \vdots
    Θ 50 = ( 1.141798154164342 e − 05 , 3.42539442494306 e − 05 ) \Theta^{50} =(1.141798154164342e^{-05}, 3.42539442494306e^{-05}) Θ50=(1.141798154164342e05,3.42539442494306e05)
    ⋮ \vdots
    Θ 100 = ( 1.6296287810675902 e − 10 , 4.8888886343202771 e − 10 ) \Theta^{100} =(1.6296287810675902e^{-10}, 4.8888886343202771e^{-10}) Θ100=(1.6296287810675902e10,4.8888886343202771e10)

    我们发现,已经基本靠近函数的最小值点
    在这里插入图片描述

    4. 代码实现

    4. 1 场景分析

    下面我们将用python实现一个简单的梯度下降算法。场景是一个简单的线性回归的例子:假设现在我们有一系列的点,如下图所示:
    在这里插入图片描述
    我们将用梯度下降法来拟合出这条直线!

    首先,我们需要定义一个代价函数,在此我们选用均方误差代价函数(也称平方误差代价函数)

    J ( Θ ) = 1 2 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 J(\Theta) = \frac{1}{2m}\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2 J(Θ)=2m1i=1m(hθ(x(i))y(i))2

    此公式中

    • m是数据集中数据点的个数,也就是样本数
    • ½是一个常量,这样是为了在求梯度的时候,二次方乘下来的2就和这里的½抵消了,自然就没有多余的常数系数,方便后续的计算,同时对结果不会有影响
    • y 是数据集中每个点的真实y坐标的值,也就是类标签
    • h 是我们的预测函数(假设函数),根据每一个输入x,根据Θ 计算得到预测的y值,即

    h Θ ( x ( i ) ) = Θ 0 + Θ 1 x 1 ( i ) h_{\Theta}(x^{(i)}) = \Theta_{0} + \Theta_{1}x_{1}^{(i)} hΘ(x(i))=Θ0+Θ1x1(i)

    我们可以根据代价函数看到,代价函数中的变量有两个,所以是一个多变量的梯度下降问题,求解出代价函数的梯度,也就是分别对两个变量进行微分

    ▽ J ( Θ ) = < δ J δ Θ 0 , δ J δ Θ 1 > \triangledown J(\Theta ) = \left < \frac{\delta J}{\delta \Theta_{0}}, \frac{\delta J}{\delta \Theta_{1}} \right > J(Θ)=δΘ0δJ,δΘ1δJ

    δ J δ Θ 0 = 1 m ∑ i = 1 m ( h Θ ( x ( i ) ) − y ( i ) ) \frac{\delta J}{\delta \Theta_{0}} = \frac{1}{m}\sum_{i=1}^{m}(h_{\Theta}(x^{(i)})-y^{(i)}) δΘ0δJ=m1i=1m(hΘ(x(i))y(i))

    δ J δ Θ 1 = 1 m ∑ i = 1 m ( h Θ ( x ( i ) ) − y ( i ) ) x 1 ( i ) \frac{\delta J}{\delta \Theta_{1}} = \frac{1}{m}\sum_{i=1}^{m}(h_{\Theta}(x^{(i)})-y^{(i)})x_{1}^{(i)} δΘ1δJ=m1i=1m(hΘ(x(i))y(i))x1(i)

    明确了代价函数和梯度,以及预测的函数形式。我们就可以开始编写代码了。但在这之前,需要说明一点,就是为了方便代码的编写,我们会将所有的公式都转换为矩阵的形式,python中计算矩阵是非常方便的,同时代码也会变得非常的简洁。
    为了转换为矩阵的计算,我们观察到预测函数的形式

    h Θ ( x ( i ) ) = Θ 0 + Θ 1 x ( i ) h_{\Theta}(x^{(i)}) = \Theta_{0} + \Theta_{1}x^{(i)} hΘ(x(i))=Θ0+Θ1x(i)

    我们有两个变量,为了对这个公式进行矩阵化,我们可以给每一个点x增加一维,这一维的值固定为1,这一维将会乘到Θ0上。这样就方便我们统一矩阵化的计算

    ( x 1 ( i ) , y ( i ) ) → ( x 0 ( i ) , x 1 ( i ) , y ( i ) ) w i t h x 0 ( i ) = 1 ∀ i (x_{1}^{(i)},y^{(i)})\rightarrow (x_{0}^{(i)},x_{1}^{(i)},y^{(i)}) with x_{0}^{(i)} = 1 \forall _{i} (x1(i),y(i))(x0(i),x1(i),y(i))withx0(i)=1i

    然后我们将代价函数和梯度转化为矩阵向量相乘的形式

    J ( Θ ) = 1 2 m ( X Θ − y ⃗ ) T ( X Θ − y ⃗ ) J(\Theta) = \frac{1}{2m}(X\Theta - \vec{y})^{T}(X\Theta - \vec{y}) J(Θ)=2m1(XΘy )T(XΘy )

    ▽ J ( Θ ) = 1 m X T ( X Θ − y ⃗ ) ) \triangledown J(\Theta) = \frac{1}{m}X^{T}(X\Theta - \vec{y})) J(Θ)=m1XT(XΘy ))

    4. 2 代码

    首先,我们需要定义数据集和学习率

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    # @Time    : 2019/1/21 21:06
    # @Author  : Arrow and Bullet
    # @FileName: gradient_descent.py
    # @Software: PyCharm
    # @Blog    :https://blog.csdn.net/qq_41800366
    
    from numpy import *
    
    # 数据集大小 即20个数据点
    m = 20
    # x的坐标以及对应的矩阵
    X0 = ones((m, 1))  # 生成一个m行1列的向量,也就是x0,全是1
    X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量,也就是x1,从1到m
    X = hstack((X0, X1))  # 按照列堆叠形成数组,其实就是样本数据
    # 对应的y坐标
    y = np.array([
        3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
        11, 13, 13, 16, 17, 18, 17, 19, 21
    ]).reshape(m, 1)
    # 学习率
    alpha = 0.01
    

    接下来我们以矩阵向量的形式定义代价函数和代价函数的梯度

    # 定义代价函数
    def cost_function(theta, X, Y):
        diff = dot(X, theta) - Y  # dot() 数组需要像矩阵那样相乘,就需要用到dot()
        return (1/(2*m)) * dot(diff.transpose(), diff)
    
    
    # 定义代价函数对应的梯度函数
    def gradient_function(theta, X, Y):
        diff = dot(X, theta) - Y
        return (1/m) * dot(X.transpose(), diff)
    

    最后就是算法的核心部分,梯度下降迭代计算

    # 梯度下降迭代
    def gradient_descent(X, Y, alpha):
        theta = array([1, 1]).reshape(2, 1)
        gradient = gradient_function(theta, X, Y)
        while not all(abs(gradient) <= 1e-5):
            theta = theta - alpha * gradient
            gradient = gradient_function(theta, X, Y)
        return theta
    
    
    optimal = gradient_descent(X, Y, alpha)
    print('optimal:', optimal)
    print('cost function:', cost_function(optimal, X, Y)[0][0])
    

    当梯度小于1e-5时,说明已经进入了比较平滑的状态,类似于山谷的状态,这时候再继续迭代效果也不大了,所以这个时候可以退出循环!
    运行代码,计算得到的结果如下:

    print('optimal:', optimal)  # 结果 [[0.51583286][0.96992163]]
    print('cost function:', cost_function(optimal, X, Y)[0][0])  # 1.014962406233101
    

    通过matplotlib画出图像,

    # 根据数据画出对应的图像
    def plot(X, Y, theta):
        import matplotlib.pyplot as plt
        ax = plt.subplot(111)  # 这是我改的
        ax.scatter(X, Y, s=30, c="red", marker="s")
        plt.xlabel("X")
        plt.ylabel("Y")
        x = arange(0, 21, 0.2)  # x的范围
        y = theta[0] + theta[1]*x
        ax.plot(x, y)
        plt.show()
    
    
    plot(X1, Y, optimal)
    

    所拟合出的直线如下
    在这里插入图片描述
    全部代码如下,大家有兴趣的可以复制下来跑一下看一下结果:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    # @Time    : 2019/1/21 21:06
    # @Author  : Arrow and Bullet
    # @FileName: gradient_descent.py
    # @Software: PyCharm
    # @Blog    :https://blog.csdn.net/qq_41800366
    
    from numpy import *
    
    # 数据集大小 即20个数据点
    m = 20
    # x的坐标以及对应的矩阵
    X0 = ones((m, 1))  # 生成一个m行1列的向量,也就是x0,全是1
    X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量,也就是x1,从1到m
    X = hstack((X0, X1))  # 按照列堆叠形成数组,其实就是样本数据
    # 对应的y坐标
    Y = array([
        3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
        11, 13, 13, 16, 17, 18, 17, 19, 21
    ]).reshape(m, 1)
    # 学习率
    alpha = 0.01
    
    
    # 定义代价函数
    def cost_function(theta, X, Y):
        diff = dot(X, theta) - Y  # dot() 数组需要像矩阵那样相乘,就需要用到dot()
        return (1/(2*m)) * dot(diff.transpose(), diff)
    
    
    # 定义代价函数对应的梯度函数
    def gradient_function(theta, X, Y):
        diff = dot(X, theta) - Y
        return (1/m) * dot(X.transpose(), diff)
    
    
    # 梯度下降迭代
    def gradient_descent(X, Y, alpha):
        theta = array([1, 1]).reshape(2, 1)
        gradient = gradient_function(theta, X, Y)
        while not all(abs(gradient) <= 1e-5):
            theta = theta - alpha * gradient
            gradient = gradient_function(theta, X, Y)
        return theta
    
    
    optimal = gradient_descent(X, Y, alpha)
    print('optimal:', optimal)
    print('cost function:', cost_function(optimal, X, Y)[0][0])
    
    
    # 根据数据画出对应的图像
    def plot(X, Y, theta):
        import matplotlib.pyplot as plt
        ax = plt.subplot(111)  # 这是我改的
        ax.scatter(X, Y, s=30, c="red", marker="s")
        plt.xlabel("X")
        plt.ylabel("Y")
        x = arange(0, 21, 0.2)  # x的范围
        y = theta[0] + theta[1]*x
        ax.plot(x, y)
        plt.show()
    
    
    plot(X1, Y, optimal)
    

    5. 小结

    至此,就基本介绍完了梯度下降法的基本思想和算法流程,并且用python实现了一个简单的梯度下降算法拟合直线的案例!
    最后,我们回到文章开头所提出的场景假设:
    这个下山的人实际上就代表了反向传播算法,下山的路径其实就代表着算法中一直在寻找的参数Θ,山上当前点的最陡峭的方向实际上就是代价函数在这一点的梯度方向,场景中观测最陡峭方向所用的工具就是微分 。在下一次观测之前的时间就是有我们算法中的学习率α所定义的。
    可以看到场景假设和梯度下降算法很好的完成了对应!

    本文部分内容来自一位前辈,非常感谢分享!谢谢!

    展开全文
  • 将拥有两个自变量的二阶函数绘制到空间坐标系中,并通过批量梯度下降算法找到并绘制其极值点 大体思路: 首先,根据题意确定目标函数:f(w1,w2) = w1^2 + w2^2 + 2 w1 w2 + 500 然后,针对w1,w2分别求偏导,编写主...
  • 自己学习吴恩达机器学习的总结,主要是关于梯度下降算法的一些推导与介绍,以及解释了,吴恩达课中没有解释推导的内容。
  • 用于多变量线性回归的梯度下降算法的 MATLAB 实现。此代码示例包括, 特征缩放选项 基于梯度范数容差或固定迭代次数的算法终止选择 具有随机指数的随机特征向量(确切的函数关系不是线性的,而是具有特征向量的随机...
  • 梯度下降并不会涉及到太太复杂的数学知识,只要稍微了解过微积分里导数的概念,就足够完全理解梯度下降的思想了。梯度下降的目的绝大多数的机器学习模型都会有一个损失函数。比如常见的均方误差(Mean Squared ...

    大部分的机器学习模型里有直接或者间接地使用了梯度下降的算法。虽然不同的梯度下降算法在具体的实现细节上会稍有不同,但是主要的思想是大致一样的。梯度下降并不会涉及到太多太复杂的数学知识,只要稍微了解过微积分里导数的概念,就足够完全理解梯度下降的思想了。

    梯度下降的目的

    绝大多数的机器学习模型都会有一个损失函数。比如常见的均方误差(Mean Squared Error)损失函数:

    (1)

    其中,

    表示样本数据的实际目标值,
    表示预测函数
    根据样本数据
    计算出的预测值。从几何意义上来说,它可以看成预测值和实际值的平均距离的平方。(关于更多的损失函数的介绍,可以参见这篇文章。)

    损失函数用来衡量机器学习模型的精确度。一般来说,损失函数的值越小,模型的精确度就越高。如果要提高机器学习模型的精确度,就需要尽可能降低损失函数的值。而降低损失函数的值,我们一般采用梯度下降这个方法。所以,梯度下降的目的,就是为了最小化损失函数。

    梯度下降的原理

    寻找损失函数的最低点,就像我们在山谷里行走,希望找到山谷里最低的地方。那么如何寻找损失函数的最低点呢?在这里,我们使用了微积分里导数,通过求出函数导数的值,从而找到函数下降的方向或者是最低点(极值点)。

    损失函数里一般有两种参数,一种是控制输入信号量的权重(Weight, 简称

    ),另一种是调整函数与真实值距离的偏差(Bias,简称
    )。我们所要做的工作,就是通过梯度下降方法,不断地调整权重
    和偏差b,使得损失函数的值变得越来越小。

    假设某个损失函数里,模型损失值

    与权重
    有下图这样的关系。实际模型里,可能会有多个权重
    ,这里为了简单起见,举只有一个权重
    的例子。权重
    目前的位置是在A点。此时如果求出A点的梯度
    ,便可以知道如果我们向右移动,可以使损失函数的值变得更小。

    a21b5c67d898d3bbd0e506658ca47af1.png

    通过计算梯度,我们就可以知道

    的移动方向,应该让
    向右走而不是向左走,也可以知道什么时候会到达最低点(梯度为0的地方)。

    上面的例子里只出现了一个权重

    , 实际的项目里样本数据会有很多个。对于每一个样本数据,我们都可以求出一个权重的梯度。这个时候,我们需要把各个样本数据的权重梯度加起来,并求出它们的平均值,用这个平均值来作为样本整体的权重梯度。

    现在知道了

    需要前进的方向,接下来需要知道应该前进多少。这里我们用到
    学习率(Learning Rate)这个概念。通过学习率,可以计算前进的距离(步长)。

    我们用

    表示权重的初始值,
    表示更新后的权重值,用
    表示学习率,则有:

    (2)

    在梯度下降中,我们会重复式子(2)多次,直至损失函数值收敛不变。

    如果学习率

    设置得过大,有可能我们会错过损失函数的最小值;如果设置得过小,可能我们要迭代式子(2)非常多次才能找到最小值,会耗费较多的时间。因此,在实际应用中,我们需要为学习率
    设置一个合适的值。

    上面讲解了对权重

    值的优化过程,对于偏差
    ,我们也可以用相同的方式进行处理,这里就不再展开了。

    梯度下降的过程

    我们把上面的内容稍微整理一下,可以得到梯度下降的整体过程:

    1. for i = 0 to 训练数据的个数:

    (1) 计算第 i 个训练数据的权重

    和偏差
    相对于损失函数的梯度。于是我们最终会得到每一个训练数据的权重和偏差的梯度值。

    (2) 计算所有训练数据权重

    的梯度的总和。

    (3) 计算所有训练数据偏差

    的梯度的总和。

    2. 做完上面的计算之后,我们开始执行下面的计算:

    (1) 使用上面第(2)、(3)步所得到的结果,计算所有样本的权重和偏差的梯度的平均值。

    (2) 使用下面的式子,更新每个样本的权重值和偏差值。

    (3)

    (4)

    重复上面的过程,直至损失函数收敛不变。

    如果用伪代码把梯度下降的过程表现出来,可以写成下面的样子:

    def 

    其他常见的梯度下降算法

    上面介绍的梯度下降算法里,在迭代每一次梯度下降的过程中,都对所有样本数据的梯度进行计算。虽然最终得到的梯度下降的方向较为准确,但是运算会耗费过长的时间。于是人们在上面这个算法的基础上对样本梯度的运算过程进行了改进,得到了下面这两种也较为常见的算法:

    1. 小批量样本梯度下降(Mini Batch GD)

    这个算法在每次梯度下降的过程中,只选取一部分的样本数据进行计算梯度,比如整体样本1/100的数据。在数据量较大的项目中,可以明显地减少梯度计算的时间。

    2. 随机梯度下降(Stochastic GD)

    随机梯度下降算法只随机抽取一个样本进行梯度计算,由于每次梯度下降迭代只计算一个样本的梯度,因此运算时间比小批量样本梯度下降算法还要少很多,但由于训练的数据量太小(只有一个),因此下降路径很容易受到训练数据自身噪音的影响,看起来就像醉汉走路一样,变得歪歪斜斜的。

    总结

    这篇文章主要讲解了梯度下降算法的作用和主要原理,给出了梯度下降算法的运算过程和伪代码实现,最后介绍了两种改进后的梯度下降算法。

    参考资料

    1. Gradient Descent : All You Need to Know by Suryansh S.

    2. Gradient Descent by ML Cheatsheet

    3. 降低损失 (Reducing Loss):梯度下降法 by google

    展开全文
  • 详解梯度下降算法

    万次阅读 2021-08-20 10:47:46
    梯度下降法(Gradient descent )是一个一阶最优化算法,通常也称为最陡下降法 ,要使用梯度下降法找到一个函数的局部极小值 ,必须向函数上当前点对应梯度(或者是近似梯度)的反方向的规定步长距离点进行迭代搜索...
  • 并与最小二乘法求解进行精度对比目录一、梯度下降算法的基本原理1、梯度下降算法的基本原理二、题目、表格数据、以及python环境搭建1、多元线性回归分析求解题目2、准备的多元线性回归方程的变量的表格数据3、搭建...
  • 多变量线性回归 题目:通过两个特征变量房子的大小和卧室的数量来预测房子的价格 编写程序的过程 一.要引进的库和导入数据集 1.要引进的库 import numpy as np import pandas as pd import matplotlib import ...
  • 梯度下降算法的正确步骤Title: What is the Gradient Descent Algorithm and its working. 标题:什么是梯度下降算法及其工作原理。 Gradient descent is a type of machine learning algorithm that helps us in ...
  • 梯度下降算法

    千次阅读 多人点赞 2019-11-29 14:14:14
    4.梯度下降 4.1什么是梯度下降梯度下降法的基本思想可以类比为一个下山的过程 ...这个时候,他就可以利用梯度下降算法来帮助自己下山。 具体来说就是,以他当前的所处的位置为基准,寻找这个位置最陡峭...
  • 针对多变量系统维数大、参数、一般的辨识算法计算量大的问题, 基于耦合辨识概念, 推导多变量系统的耦合随机梯度算法, 利用鞅收敛定理分析算法的收敛性能. 算法的主要思想是将系统模型分解为个单输出子系统,在子...
  • 为提高基于随机并行梯度下降(SPGD)算法的高分辨率自适应光学(AO)系统的有效校正带宽, 提出了分级SPGD波前校正的方法。在每一级SPGD波前校正中, 将高分辨率波前校正器的控制单元按位置分成组, 每一组都施加相同的...
  • Tensorflow实现梯度下降的单变量线性回归模型,使用到的库:TensorFlow、Numpy、Matplotlib
  • 2.2 梯度下降(Gradient Descent) 2.2.1 什么是梯度下降 梯度下降法的基本思想可以类比为一个下山的过程。 假设这样一个场景: 一个人被困在山上,需要从山上下来(i.e. 找到山的最低点,也就是山谷)。但此时山上...
  • 梯度下降法的基本思想可以类比为一个下山的...这个时候,他就可以利用梯度下降算法来帮助自己下山。具体来说就是,以他当前的所处的位置为基准,寻找这个位置最陡峭的地方,然后朝着山的高度下降的地方走,同理,如...
  • Pytorch学习笔记04----梯度下降算法

    千次阅读 2022-03-29 23:31:37
      本文主要对梯度下降算法的基本原理进行了讲解,然后使用手写梯度下降算法解决了线性回归问题。最后对 PyTorch 中的反向传播函数进行了讲解并利用该函数简明快速的完成了损失的求导与模型的训练。 梯度下降算法一...
  • 梯度下降算法原理讲解

    千次阅读 2021-09-02 20:28:03
    优化算法中,梯度下降法是最简单、最常见的一种,在深度学习的训练中被广为使用。在本文中,SIGAI 将为大家系统的讲述梯度下降法的原理和实现细节问题最优化问题最优化问题是求解函数极值的问题,包括极大值和极小值...
  • 梯度下降算法详细解析及代码实现

    千次阅读 2019-05-21 16:48:09
    如有冒犯,还望谅解! 梯度下降的场景假设 梯度 ...本文将从一个下山的场景开始,先提出梯度下降算法的基本思想,进而从数学上解释梯度下降算法的原理,最后实现一个简单的梯度下降算法的实例!...
  • 梯度下降算法简明教程

    千次阅读 2018-10-21 20:03:52
    当然运用梯度算法的地方远不止逻辑回归,该方法思路简单但适用范围很广,简单的线性回归(Linear Regression),以及最近在看的神经网络(Neural Network)都有涉及梯度算法,所以掌握该方法还是很有必要的,下面来...
  • 用于评估机器学习模型的就是损失函数,我们训练的目的基本上都是最小化损失,这个最小化的方式就要用优化算法了,机器学习中最常用的就是梯度下降算法。 导数、方向导数和梯度 要了解梯度下降算法是什么首要知道...
  • [机器学习] 梯度下降优化算法前言常见的梯度下降优化算法Gradient DescentStochastic Gradient Descent (SGD)SGD with momentumAdaptive Gradient (AdaGrad)RMSpropAdam什么是机器学习中最佳优化算法 前言 为什么...
  • 梯度下降
  • 机器学习与深度学习梯度下降、坐标下降优化方法总结
  • 梯度下降(gradient descent)算法是一种非常经典的求极小值的算法,其理论基础是梯度的概念。 先从一个生活中的问题引入梯度下降的概念。 假设在一个夜晚,你处于一座山峰的顶端,你需要从山顶回到山底的营地,...
  • 什么是多元线性回归(multivariate linear regression)概念假设函数(hypothesis function)特征梯度下降算法 概念 多元线性回归是变量(Multiple features)的线性回归。以下图为例: 其中,我们通过变量x1...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 71,508
精华内容 28,603
关键字:

多变量梯度下降算法