精华内容
下载资源
问答
  • 这篇是西瓜书第五章的公式推导笔记,主要在于对公式推导过程说明的笔记,但是博客标注转载需要原文链接,我没有啊,所以写了原创,愧疚。

    这篇是西瓜书第五章的公式推导笔记,主要在于对公式推导过程说明的笔记,但是博客标注转载需要原文链接,我没有啊,所以写了原创,愧疚。

     

     

     

    下面开始是推导过程的近一步的解释。

    首先:BP算法的梯度下降(gradient descent)是梯度的反方向,所以有个负号。 

    先看

     η是学习率,后面是偏导数,再乘以-1(梯度反方向嘛)

    根据链式法则,求偏导一个一个分解过程,所以这个链式法则应该都能看懂了。

    过程如下:

    类似可得,这个真的类似:

     

    展开全文
  • 什么是梯度下降,举个栗子,(假设地面无障碍物)我们在山顶丢一个网球,啪,一下就越过这个坡了,然后在另一个沟里来回跳动,一直到达最低点。那么问题来了,这这里在跳跃的过程中,直接越过第一个坡度。这样的结果...

     

    什么是梯度下降,举个栗子,(假设地面无障碍物)我们在山顶丢一个网球,啪,一下就越过这个坡了,然后在另一个沟里来回跳动,一直到达最低点。那么问题来了,这这里在跳跃的过程中,直接越过第一个坡度。这样的结果就是使得我们的小球无法到达最低点,对应到程序上就是我们在梯度下降的时候无法找到最优值。

                                                               

    梯度下降,就是是在不断就是出于最高点,先下走一个步长,不断的走,或回撤步长的过程。使得我们找到目标的最优值。那么有个问题就是步长(也称为学习率)取值为多少才适合? 过大的步长容易使得跳过最优值,过小的步长使得梯度下降的效率过低。

    梯度下降的过程,其实就是迭代求解的过程.

    在公式推导之前,我们先引入预测值函数

                                                          

                                             hθ(x) :预测值           θ1 :权重                           θ0 :偏置

     还有,损失函数(也叫代价函数)

                                             

    该损失函数是由高斯分布的预测误差求取对数拟然函数,结果的被减项得出的.原结果1/2并不是1/2m,这里分母加了m,是为了去除样本对损失函数的影响,是的减少样本数对损失函数的影响. (这里如果为加1/m,结果将是样本次数越多,损失函数越大,样本对损失函数的影响非常大.)

     

    根据损失函数,我们接下来对 权重θ1 与 偏置 θ0 ,求取对应的偏导数.

                                                             

                                                    

    上面的  α 就是我们设置的学习率.

     

    接下来我们将使用高尔夫球的案例来写梯度下降的算法.

    链接:https://pan.baidu.com/s/1GJ20Kha2AMF5Qw0hRUarVQ 
    提取码:0fjw 
    数据集我保存到云盘,需要的可以自己下载一下

    #梯度下降
    import pandas
    import matplotlib.pyplot as plt
    
    # 高尔夫球数据集
    pga = pandas.read_csv("pga.csv")
    
    
    # 数据标准化
    pga.distance = (pga.distance - pga.distance.mean()) / pga.distance.std()
    pga.accuracy = (pga.accuracy - pga.accuracy.mean()) / pga.accuracy.std()
    print(pga.head())
    
    plt.scatter(pga.distance, pga.accuracy)
    plt.xlabel('normalized distance')
    plt.ylabel('normalized accuracy')
    plt.show()

     

     

    ##distance: 挥杆之后的距离

    ## accuracy : 精度

    # accuracyi=θ1distancei+θ0+ϵ
    
    from sklearn.linear_model import LinearRegression
    import numpy as np
    
    # We can add a dimension to an array by using np.newaxis
    print("Shape of the series:", pga.distance.shape)
    print("Shape with newaxis:", pga.distance[:, np.newaxis].shape)
    
    # fit()中的X变量必须是二维的
    lm = LinearRegression()
    lm.fit(pga.distance[:, np.newaxis], pga.accuracy)
    theta1 = lm.coef_[0]
    print (theta1)

     

     

    # 单变量线性模型的成本函数
    # hθ(x) = θ1X + θ0
    #计算损失函数,J(θ0,θ1) = 1/2m *累加 (hθ(Xi)-Yi)**2
    def cost(theta0, theta1, x, y):
        # 初始化成本
        J = 0
        # 观测次数
        m = len(x)
        # 遍历每个观测值
        for i in range(m):
            # 计算假设 
            h = theta1 * x[i] + theta0
            # 累加成本
            J += (h - y[i])**2
        # 平均和规范成本
        J /= (2*m)
        return J
    
    # 损失函数 theta0=0 and theta1=1
    print(cost(0, 1, pga.distance, pga.accuracy))
    
    theta0 = 100
    theta1s = np.linspace(-3,2,100)
    costs = []
    for theta1 in theta1s:
        costs.append(cost(theta0, theta1, pga.distance, pga.accuracy))
    
    plt.plot(theta1s, costs)
    plt.show()

    import numpy as np
    from mpl_toolkits.mplot3d import Axes3D
    
    # 使用Matplotlib的地表绘图示例
    # 创建x和y变量
    x = np.linspace(-10,10,100)
    y = np.linspace(-10,10,100)
    
    # 我们必须创建变量来表示x和y中每一对可能的点
    # ie. (-10, 10), (-10, -9.8), ... (0, 0), ... ,(10, 9.8), (10,9.8)
    # x和y需要转换成100x100矩阵来表示这些坐标
    # np.meshgrid will build a coordinate matrices of x and y
    X, Y = np.meshgrid(x,y)
    #print(X[:5,:5],"\n",Y[:5,:5])
    
    # 计算一个三维抛物线
    Z = X**2 + Y**2 
    
    # 打开一个画布
    fig = plt.figure()
    # I初始化3 d图
    ax = fig.gca(projection='3d')
    # 绘制图像
    ax.plot_surface(X=X,Y=Y,Z=Z)
    
    plt.show()
    
     
    theta0s = np.linspace(-2,2,100)
    theta1s = np.linspace(-2,2, 100)
    COST = np.empty(shape=(100,100))
    # Meshgrid为参数
    T0S, T1S = np.meshgrid(theta0s, theta1s)
    # 累计每个参数组合计算成本
    for i in range(100):
        for j in range(100):
            COST[i,j] = cost(T0S[0,i], T1S[j,0], pga.distance, pga.accuracy)
    
    # 绘制3d图
    fig2 = plt.figure()
    ax = fig2.gca(projection='3d')
    ax.plot_surface(X=T0S,Y=T1S,Z=COST)
    plt.show()

    #假设函数的权重求导
    def partial_cost_theta1(theta0, theta1, x, y):
        # 假设函数
        h = theta0 + theta1*x
        # 对θ1求导后的公式进行计算,θ1的偏导数
        diff = (h - y) * x
        # 累加偏导数和,除于样本个数
        partial = diff.sum() / (x.shape[0])
        return partial
    
    partial1 = partial_cost_theta1(0, 5, pga.distance, pga.accuracy)
    print("partial1 =", partial1)
    
    
    #假设函数的偏置求导
    def partial_cost_theta0(theta0, theta1, x, y):
        # 假设函数
        h = theta0 + theta1*x
        # 对θ0求导后的公式进行计算,θ1的偏导数
        diff = (h - y)
        # 累加偏导数和,除于样本个数
        partial = diff.sum() / (x.shape[0])
        return partial
    
    partial0 = partial_cost_theta0(1, 1, pga.distance, pga.accuracy)

     

    # x是特征向量 -- distance
    # y 是目标标签 -- accuracy
    # alpha 是学习率
    # theta0 是偏置
    # theta1 是权重
    def gradient_descent(x, y, alpha=0.1, theta0=0, theta1=0):
        max_epochs = 1000 # 最大迭代次数
        counter = 0      # 计数器
        c = cost(theta1, theta0, pga.distance, pga.accuracy)  ## 损失函数
        costs = [c]     # 储存损失函数
        # 设置收敛阈值,找出代价函数在何处最小
        # 以前成本与当前成本之差,小于这个值我们就说参数收敛了,即已经快找点目标了    
        convergence_thres = 0.000001  #收敛的阈值
        cprev = c + 10   #这里加10是为了设置一个起始值,要计算起始值与损失函数的距离
        theta0s = [theta0]
        theta1s = [theta1]
    
        # 当成本收敛或我们遇到大量迭代时,我们将停止更新
        while (np.abs(cprev - c) > convergence_thres) and (counter < max_epochs):
            cprev = c #这里把损失函数的值赋给了起始值,使得范围进一步缩小
            # 学习率乘与对θ求导
            update0 = alpha * partial_cost_theta0(theta0, theta1, x, y)
            update1 = alpha * partial_cost_theta1(theta0, theta1, x, y)
    
            # 同时更新theta0和theta1
            # 我们想要在同一组假设参数下计算斜率,所有要求出偏导后再更新     
            theta0 -= update0
            theta1 -= update1
            
            # 保存 thetas
            theta0s.append(theta0)
            theta1s.append(theta1)
            
            # 计算新损失函数
            c = cost(theta0, theta1, pga.distance, pga.accuracy)
    
            # 保存更新
            costs.append(c)
            counter += 1   # Count
    
        return {'theta0': theta0, 'theta1': theta1, "costs": costs}
    
    print("Theta1 =", gradient_descent(pga.distance, pga.accuracy)['theta1'])#输出权重
    descend = gradient_descent(pga.distance, pga.accuracy, alpha=.01)
    plt.scatter(range(len(descend["costs"])), descend["costs"])
    plt.show()

    展开全文
  • Logistic回归cost函数的推导过程。...对于一个函数,我们要找它的最小值,有多种算法,这里我们选择比较容易用代码实现和符合机器学习步骤的梯度下降算法。 先来看看梯度下降算法中,自变量的迭代过程...

    转自:https://blog.csdn.net/javaisnotgood/article/details/78873819

    Logistic回归cost函数的推导过程。算法求解使用如下的cost函数形式:

     

     

    梯度下降算法

    对于一个函数,我们要找它的最小值,有多种算法,这里我们选择比较容易用代码实现和符合机器学习步骤的梯度下降算法。

    先来看看梯度下降算法中,自变量的迭代过程。表示如下

      

    可以看到,这是一个θ值不断迭代的过程,其中α是学习速率,就是θ的移动“步幅”,后面的偏导数数就是梯度,可以理解为cost函数在θ当前位置,对于j位置特征的下降速度。

      对于二维空间,梯度可以理解为函数图像的切线斜率。即:特征是一维的

      对于多维特征,cost函数的图像就应该是这样的,下面举个例子:

      

                                图1 cost函数举例

     

     

      这是一个二维特征的cost函数的图像,这个时候,梯度有无限多个,我们不能只说cost函数的梯度,应该说,cost函数在某个方向上的梯度。例如,cost函数在θ0方向上,在(θ0=m,θ1=n)上的梯度就是cost函数与θ1=n这个平面的交线在(m,n)处的斜率。

      上面的描述比较抽象,简单说来,假设图像就是一个小山坡(有点像吧),你站在图像的(m,n)点处,朝θ0的方向看过去,看到的“山坡”的“坡度”就是上面所说的梯度了。

      这个迭代过程,用形象化的语言描述,就是:

        我站在山坡上,找到一个初始点θj,每次我沿着某一个方向走α这么长的路,由于总是朝着梯度的方向走,我总会走到山坡底(也就是cost函数的极小值)。

      然而,这样的“盆地”可能有多个,我们不同的走法,可能会走到不同的山底,如图:

     

                               图2 多“山谷”cost函数

     

      这里的两条路线分别走向不同的山谷,这就说明:梯度下降算法只能求出一个局部最小值,不一定是全局最小值,但这不影响它是一个好的方法。

     

    这样,θ的迭代过程就讲清楚了。接下来说一下迭代的终止条件。

      迭代肯定不是无限下去的,我们不妨想一下:当我们走到了山谷,再想往某个方向走的时候,发现都不能再往下走了,那么我们的旅行就终止了。

      同样,当θ迭代了n次后(就如图2的黑线一样),发现接下来走α这么长的路,下降的高度很小很小(临界值),或者不再下降,甚至反而往上走了,所以我们的迭代终止条件就是cost函数的减少值小于某个值。

      我们再来回顾一下迭代公式(1):其中α是经验设定,称之为learning rate,初始值也是随机选定,那么后面的那个梯度呢?

      梯度就是cost函数对于特征向量某一维的偏导数。我们来看看这个怎么推导和简化。

      【梯度的求解】

      推导过程:

      解释一下推导流程,便于理解。

      (1)--->(2):使用sigmoid函数的形式g(z)替换hθ(x)、提出公因子,放在式子尾

      (2)--->(3):这一步具体推导如下(使用了复合函数的求导公式)

     

      后面的几步较为简单,就不另作说明了。

      【算法运行】

      到了这里,我们推出了迭代公式的最终形式:

      更一般的形式就是把j去掉,表示对特征的每一维都如此迭代

      注意,在迭代过程中,θ的所有特征是同步更新的,所以根据给定的数据集,就能使用梯度下降算法来求解θ了,迭代终止条件即是将当前θ带入cost函数,求出代价值,与上一个代价值相减,结果小于阈值,立即停止迭代。

    转载于:https://www.cnblogs.com/peterwong666/p/11089836.html

    展开全文
  • mllib之梯度下降公式推导

    千次阅读 2015-03-25 00:15:14
    梯度下降(GD)是最小化风险函数、损失函数的一种常用方法,随机梯度下降和批量梯度下降是两种迭代求解思路,下面从公式和实现的角度对两者进行分析,如有哪个方面写的不对,希望网友纠正。 下面的h(x)是要拟合的...

    梯度下降(GD)是最小化风险函数、损失函数的一种常用方法,随机梯度下降和批量梯度下降是两种迭代求解思路,下面从公式和实现的角度对两者进行分析,如有哪个方面写的不对,希望网友纠正。


    下面的h(x)是要拟合的函数,J(theta)损失函数,theta是参数,要迭代求解的值,theta求解出来了那最终要拟合的函数h(theta)就出来了。其中m是训练集的记录条数,j是参数的个数。



    1、批量梯度下降的求解思路如下:

    (1)将J(theta)对theta求偏导,得到每个theta对应的的梯度

      

          以上的推导的结果,请看如下推导过程:

         

    (2)由于是要最小化风险函数,所以按每个参数theta的梯度负方向,来更新每个theta


          该步骤详解:由步骤一求导出来的就是梯度,那么梯度负方向就是梯度的反方向,即把它取反就可以了(即加个负号,再加上它自己);要更新每个变量,负梯度就相当于一个向量。

    (3)从上面公式可以注意到,它得到的是一个全局最优解,但是每迭代一步,都要用到训练集所有的数据,如果m很大,那么可想而知这种方法的迭代速度!!所以,这就引入了另外一种方法,随机梯度下降。


    2、随机梯度下降的求解思路如下:

    (1)上面的风险函数可以写成如下这种形式,损失函数对应的是训练集中每个样本的粒度,而上面批量梯度下降对应的是所有的训练样本:


    (2)每个样本的损失函数,对theta求偏导得到对应梯度,来更新theta

    (3)随机梯度下降是通过每个样本来迭代更新一次,如果样本量很大的情况(例如几十万),那么可能只用其中几万条或者几千条的样本,就已经将theta迭代到最优解了,对比上面的批量梯度下降,迭代一次需要用到十几万训练样本,一次迭代不可能最优,如果迭代10次的话就需要遍历训练样本10次。但是,SGD伴随的一个问题是噪音较BGD要多,使得SGD并不是每次迭代都向着整体最优化方向。


    3、对于上面的linear regression问题,与批量梯度下降对比,随机梯度下降求解的会是最优解吗?

    (1)批量梯度下降---最小化所有训练样本的损失函数,使得最终求解的是全局的最优解,即求解的参数是使得风险函数最小。

    (2)随机梯度下降---最小化每条样本的损失函数,虽然不是每次迭代得到的损失函数都向着全局最优方向, 但是大的整体的方向是向全局最优解的,最终的结果往往是在全局最优解附近。


    4、梯度下降用来求最优解,哪些问题可以求得全局最优?哪些问题可能局部最优解?

    对于上面的linear regression问题,最优化问题对theta的分布是unimodal,即从图形上面看只有一个peak,所以梯度下降最终求得的是全局最优解。然而对于multimodal的问题,因为存在多个peak值,很有可能梯度下降的最终结果是局部最优。


    5、随机梯度和批量梯度的实现差别

    以前一篇博文中NMF实现为例,列出两者的实现差别(注:其实对应python的代码要直观的多,以后要练习多写python!)

    	// 随机梯度下降,更新参数
    	public void updatePQ_stochastic(double alpha, double beta) {
    		for (int i = 0; i < M; i++) {
    			ArrayList<Feature> Ri = this.dataset.getDataAt(i).getAllFeature();
    			for (Feature Rij : Ri) {
    				// eij=Rij.weight-PQ for updating P and Q
    				double PQ = 0;
    				for (int k = 0; k < K; k++) {
    					PQ += P[i][k] * Q[k][Rij.dim];
    				}
    				double eij = Rij.weight - PQ;
    
    				// update Pik and Qkj
    				for (int k = 0; k < K; k++) {
    					double oldPik = P[i][k];
    					P[i][k] += alpha
    							* (2 * eij * Q[k][Rij.dim] - beta * P[i][k]);
    					Q[k][Rij.dim] += alpha
    							* (2 * eij * oldPik - beta * Q[k][Rij.dim]);
    				}
    			}
    		}
    	}
    
    	// 批量梯度下降,更新参数
    	public void updatePQ_batch(double alpha, double beta) {
    
    		for (int i = 0; i < M; i++) {
    			ArrayList<Feature> Ri = this.dataset.getDataAt(i).getAllFeature();
    
    			for (Feature Rij : Ri) {
    				// Rij.error=Rij.weight-PQ for updating P and Q
    				double PQ = 0;
    				for (int k = 0; k < K; k++) {
    					PQ += P[i][k] * Q[k][Rij.dim];
    				}
    				Rij.error = Rij.weight - PQ;
    			}
    		}
    
    		for (int i = 0; i < M; i++) {
    			ArrayList<Feature> Ri = this.dataset.getDataAt(i).getAllFeature();
    			for (Feature Rij : Ri) {
    				for (int k = 0; k < K; k++) {
    					// 对参数更新的累积项
    					double eq_sum = 0;
    					double ep_sum = 0;
    
    					for (int ki = 0; ki < M; ki++) {// 固定k和j之后,对所有i项加和
    						ArrayList<Feature> tmp = this.dataset.getDataAt(i).getAllFeature();
    						for (Feature Rj : tmp) {
    							if (Rj.dim == Rij.dim)
    								ep_sum += P[ki][k] * Rj.error;
    						}
    					}
    					for (Feature Rj : Ri) {// 固定k和i之后,对多有j项加和
    						eq_sum += Rj.error * Q[k][Rj.dim];
    					}
    
    					// 对参数更新
    					P[i][k] += alpha * (2 * eq_sum - beta * P[i][k]);
    					Q[k][Rij.dim] += alpha * (2 * ep_sum - beta * Q[k][Rij.dim]);
    				}
    			}
    		}
    	}


     

    点击查看原文

     

     

     

     

     

     

     

     

     

    展开全文
  • 之前在看批量梯度下降的时候,看到代价函数J(w)的求导过程中,一直搞不明白它是怎么推导出来的,今天终于把它推导出来了。
  • 文中元学习(Meta Learning)是学习了李宏毅教授的视频... 提出问题: 根据参数更新的第一,二两个公式,可以将公式一中的梯度写成如下: 此时,有一个问题,梯度是 那么 公式推导 所以
  • Logistic回归代价函数的梯度下降公式推导过程Logistic回归代价函数梯度下降公式数学推导过程数学推导过程如下 Logistic回归代价函数梯度下降公式数学推导过程 因为最近在学习吴恩达的机器学习,这只是个人顺手保存...
  • 这要从梯度下降算法推导来理解: 首先看一下梯度的定义: 看不懂也没关系,只要认识梯度的符号▽ 请看下面的推导过程: 可以发现5.19和5.23很相似,就可以将5.19的推论应用到5.23来理解。 5.19:对x的变化更新,...
  • 梯度下降数学解释: 场景假设 梯度下降法的基本思想可以类比为一个下山的过程。 假设这样一个场景:一个人被困在山上,需要从山上下来(找到山的最低点)。但此时山上的浓雾很大,导致可视度很低;因此,下山的路径...
  • 梯度下降公式推导

    千次阅读 2019-07-28 15:52:22
    梯度下降梯度下降法是求解无约束最优化问题的一种最常用的方法,是一种迭代算法,每一步需要求解目标函数的梯度向量。 梯度的定义: 某一函数沿着某点处的方向导数可以以最快速度到达极大值,该方向导数我们...
  • 梯度下降推导

    2020-09-20 15:03:46
    梯度下降公式推导 ** 梯度下降法简单的来说就是一种寻找最小值的点的方法,是机器学习和深度学习中常用的优化器,具体又可分为批量梯度下降(BGD)、随机梯度下降(SGD)和小批量梯度下降(MBGD),本文不对这些...
  • 逻辑回归梯度下降公式详细推导

    千次阅读 2015-09-30 00:40:57
    标签(空格分隔): 机器学习 在一次面试中被问道了逻辑回归公式推导,虽然知道原理,但是从来未从头到尾推导过,面试时估计有点困,又不完全熟悉,又略有紧张(借口找的齐全了…)。面试官还算仁慈,没有太严格...
  • 根据《统计学习方法》第6章中6.1节介绍,下面对损失函数以及参数www的梯度下降公式推导: SigmoidSigmoidSigmoid函数为: g(z)=11+e−zg(z)=\frac{1}{1+e^{-z}}g(z)=1+e−z1​ 给定一个样本xxx,可以使用一个线性...
  • 文章目录前言公式推导总结 前言 什么是AI? The theory and development of ...其实不用泰勒展开式也是可以简单方便的得出梯度下降法的结论的,在高数书本(同济)的微分的定义里就有讲到(我看的是同济7版第113页和
  • 梯度下降算法推导

    2020-03-22 16:29:57
    没关系,接下来我将以通俗的语言来详细解释梯度下降算法公式的数学推导过程。 下山问题 假设我们位于黄山的某个山腰处,山势连绵不绝,不知道怎么下山。于是决定走一步算一步,也就是每次沿着当前位...
  • 梯度下降及反向传递公式推导 之前发布在作业部落了,可以通过这个链接访问,其中的数学公式转过来比较麻烦,先看作业部落的链接吧:https://www.zybuluo.com/JackMeGo/note/1052246 ...
  • 机器学习中逻辑回归的梯度下降算法中theta更新公式推导
  • 深度学习之反向传播与梯度下降   有了前馈神经网络,又有了损失函数,就可以使用反向传播算法来更新神经网络中的参数,使得网络的输出尽可能地接近真实值。反向传播算法就是通过链式法则,从最后面的损失函数开始...
  •   在深度学习领域,我们往往采用梯度下降(或上升)法来优化训练函数模型,梯度下降法尤其是在优化凸函数上表现极佳。模型优化涉及到反向传播过程,反向传播过程需要先推导出梯度计算公式然后利用机器进行代数运算。...
  • 梯度下降法的基本思想非常简单,想象一下自己在一个盆地中,现在需要进入到盆地最底部,那么最简单的方式就是一直往下走,直到不能再向下走为止,此时就到达了盆地最底部。那么对于一个复杂的函数而言,找到一个合适...
  • 梯度下降的矩阵分解公式推导与实例分析 当我们了解和学习过梯度下降之后,对于矩阵分解的学习会更直接易懂。 矩阵分解就是将一个大的矩阵分解成两个行对应列相等的两个小矩阵,用两个小的矩阵去预测大的矩阵的取值。...
  • 梯度下降法复杂度计算与公式推导

    千次阅读 2019-05-26 19:39:00
    梯度下降法的好坏的评估与公式推导 如何评估一个梯度下降法的好坏 通过自己的数据进行实际代码运行测试,看看时间性能如何。但是这样子不能直观看出类似于:quick sort(nlogn)这样的复杂度 通过公式进行复杂度评估 ...
  • 前面一篇就是基础性的推导过程。从反馈的情况看,总体还是讲明白了。但是在导数的部分,仍有不少的存疑。 其实在数学方面,我也是学渣。所以尽我所能,希望再次的补充能讲的明白。若有谬误,期盼指正。 基础公式 所...
  • 理解梯度首先要理解导数、偏导数、方向导数。 导数: 指的是一元函数y=f(x)y = f(x)y=f(x) 在某一点处沿x轴正方向的变化率。若导数大于0,说明函数值在该点处沿x轴正方向是递增的,若导数小于0,说明函数值在该...
  • 梯度下降算法推导(笔记)

    千次阅读 2017-10-09 21:55:08
    一直对ML中各种数学推导...1.梯度下降是ML中应用最广泛的用于求解模型参数的算法(类似算法还有牛顿法、拟牛顿法、共轭方向、共轭梯度法等)。原理主要是对损失函数的每一个函数求导,并利用负梯度对权值w进行更新。
  • 目标函数是要最小化C:  求其梯度:  梯度下降求最小值:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 522
精华内容 208
关键字:

梯度下降公式推导