机器学习算法之梯度下降

于 2022-10-28 17:31:17 发布
阅读量176 收藏
点赞数
分类专栏： 机器学习 文章标签： 机器学习 算法 python 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52004821/article/details/127575774
版权

1. 梯度下降法简介

1-1
以下是定义了一个损失函数以后，参数theta对应的损失函数J的值对应的示例图，我们需要找到使得损失函数值J取得最小值对应的theta（这里是二维平面，也就是我们的参数只有一个）

在直线方程中，导数代表斜率
在曲线方程中，导数代表切线斜率
导数代表theta单位变化时，J相应的变化
1-2
1-3
η太小，会减慢收敛学习速度
1-4
η太大，甚至导致不收敛
1-5

其他注意事项

  • 并不是所有函数都有唯一的极值点
    1-6
    解决方案：
    • 多次运行，随机化初始点
    • 梯度下降法的初始点也是一个超参数

1-7

2 梯度下降法模拟

2.1 实现

import numpy as np
import matplotlib.pyplot as plt
# 简单模拟一个损失函数
plot_x = np.linspace(-1,6,141)
plot_y = (plot_x-2.5)**2-1
# 绘制我们模拟的损失函数
plt.plot(plot_x,plot_y)

2.1-1

def dJ(theta):
    """损失函数的导数"""
    return 2*(theta-2.5)

def J(theta):
    """损失函数"""
    try:
        return (theta-2.5)**2-1
    except:
        return float('inf')

def gradient_descent(initial_theta,eta,n_iters = 1e4,epsilon=1e-8):
    """
    梯度下降法封装
    initial_theta:初始化的theta值
    eta:学习率η
    n_iters: 最大循环次数
    epsilon: 精度
    """
    theta = initial_theta
    # theta_history 保存theta的变化值
    theta_history.append(initial_theta)
    i_iters = 0
    
    while i_iters<n_iters:
        """
        如果theta两次变化之间的损失函数值的变化小于我们定义的精度
        则可以说明我们已经找到了最低的损失函数值和对应的theta
        
        如果循环次数超过了我们设置的循环次数，
        则说明可能由于η设置的过大导致无止境的循环
        """
        gradient = dJ(theta)
        last_theta = theta
        theta = theta - eta * gradient
        theta_history.append(theta)
        
        if (abs(J(theta)-J(last_theta)) < epsilon):
            break
        i_iters += 1

def plot_theta_history():
    plt.plot(plot_x,J(plot_x))
    plt.plot(np.array(theta_history),J(np.array(theta_history)),color='r',marker='+')
    print("the size of theta_history is %d"%len(theta_history))

2.2 使用不同η学习率测试并观察我们的梯度下降法的结果

eta = 0.1
theta_history = []
gradient_descent(0.,eta)
plot_theta_history()

2.2-1

eta = 0.01
theta_history = []
gradient_descent(0.,eta)
plot_theta_history()

2.2-2

eta = 0.001
theta_history = []
gradient_descent(0.,eta)
plot_theta_history()

2.2-3

eta = 0.8
theta_history = []
gradient_descent(0.,eta)
plot_theta_history()

2.2-4
可以发现，只要η不超过一个限度，我们编写的函数都可以在有限次数之后找到最优解，并且η越小，学习的次数越多
下面来看一下，如果eta取较大值1.1，会出现什么情况

eta = 1.1
theta_history = []
gradient_descent(0.,eta)
# 数据量太大会报错
# plot_theta_history()
print(len(theta_history))
# 输出10001
theta_history[-1]
# 输出 nan（not a number）

可以看出当我们的eta取1.1，函数会循环直至终止，这是由于，我们的η设置过大，导致每次循环过后，损失函数j的值都向大的方向变化

eta = 1.1
theta_history = []
gradient_descent(0.,eta,n_iters = 10)
plot_theta_history()

2.2-5

3 多元线性回归中的梯度下降法

3-1
一个三维空间中的梯度下降法（x,y为系数，z为损失函数）
3-2
推导过程
3-3
3-4
上面推导出的式子的大小是和样本数有关的，m越大，结果越大，这是不合理的，我们希望和m无关
3-5

4 线性回归中的梯度下降法的实现

4.1 比较笨的方法实现

def fit_gd(self, X_train, y_train, eta=0.01, n_iters = 1e4):
        """根据训练数据集X_train,y_train, 使用梯度下降法训练Linear Regression 模型"""
        assert X_train.shape[0] == y_train.shape[0], \
            "the size of X_train must be equal to the size of y_train"

        def J(theta, X_b, y):
            try:
                return np.sum((y - X_b.dot(theta))**2) / len(X_b)
            except:
                return float('inf')

        def dJ(theta, X_b, y):
            res = np.empty(len(theta))
            res[0] = np.sum(X_b.dot(theta) - y)

            for i in range(1, len(theta)):
                res[i] = np.sum((X_b.dot(theta) - y).dot(X_b[:, i]))

            return res * 2 / len(X_b)

        def gradient_descent(X_b, y, initial_theta, eta, n_iters=n_iters, epsilon=1e-8):
            """
            梯度下降法封装
            X_b: X特征矩阵
            y: 结果向量
            initial_theta:初始化的theta值
            eta:学习率η
            n_iters: 最大循环次数
            epsilon: 精度
            """
            theta = initial_theta
            i_iters = 0

            while i_iters < n_iters:
                """
                如果theta两次变化之间的损失函数值的变化小于我们定义的精度
                则可以说明我们已经找到了最低的损失函数值和对应的theta
                
                如果循环次数超过了我们设置的循环次数，
                则说明可能由于η设置的过大导致无止境的循环
                """
                gradient = dJ(theta, X_b, y)
                last_theta = theta
                theta = theta - eta * gradient

                if abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon:
                    break

                i_iters += 1

            return theta

        X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
        initial_theta = np.zeros(X_b.shape[1])
        self._theta = gradient_descent(X_b, y_train, initial_theta, eta)

        self.interception_ = self._theta[0]
        self.coef_ = self._theta[1:]

        return self

4.2 测试我们的算法

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(666)
x = 2*np.random.random(size = 100)
# 定义截距为4 斜率为3
y = x * 3. + 4. + np.random.normal(size=100)
X = x.reshape(-1,1)
plt.scatter(x,y)

4.2-1

from machine_learning.LinearRegression import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit_gd(X,y)

lin_reg.interception_
# 4.021457858204859
lin_reg.coef_
# array([3.00706277])

4.3 向量化

4.3-1
4.3-2
4.3-3

修改之前的求导函数

def dJ(theta, X_b, y):
            # res = np.empty(len(theta))
            # res[0] = np.sum(X_b.dot(theta) - y)
            #
            # for i in range(1, len(theta)):
            #     res[i] = np.sum((X_b.dot(theta) - y).dot(X_b[:, i]))
            #
            # return res * 2 / len(X_b)
            return X_b.T.dot(X_b.dot(theta) - y) * 2. / len(X_b)

使用真实的数据测试
4.3-4
使用真实的数据，调整eta和iters，要么由于eta太小导致无法得出真实的结果，要么由于eta太大导致训练时间加长，这是由于数据的规模在不同的特征上不同，所以我们需要对数据进行归一化

4.4 数据归一化

4.4-1

4.4-2

4.4-3

如果样本数非常多，那么即使使用梯度下降法也会导致速度比较慢，因为在梯度下降法中，每一个样本都要参与运算。这时候需要采用随机梯度下降法，下面会介绍

5 随机梯度下降法

5.1 随机梯度下降法介绍

5.1
批量梯度下降法带来的一个问题是η的值需要设置的比较小，在样本数比较多的时候导致不是速度特别慢，这时候观察随机梯度下降法损失函数的求导公式，可以发现，我们对每一个Xb都做了求和操作，又在最外面除以了m，那么可以考虑将求和和除以m的两个运算约掉，采用每次使用一个随机的Xb
5.2
5.3
由于我们使用的事随机梯度下降法，所以导致我们的最终结果不会像批量梯度下降法一样准确的朝着一个方向运算，而是曲线行下降，这时候我们就希望，越到下面，η值相应减小，事运算次数变多，从而精确计算结果
5-4
这里使用了模拟退火的思想
5-5

5.2 随机梯度下降法实现

def dJ_sgd(theta,X_b_i,y_i):
    return X_b_i.T.dot(X_b_i.dot(theta) - y_i) * 2

def sgd(X_b,y,initial_theta,n_iters):
    
    t0 = 5
    t1 = 50
    
    def learning_rate(t):
        return t0 / (t + t1)
    
    theta = initial_theta
    for cur_iter in range(n_iters):
        rand_i = np.random.randint(len(X_b))
        gradient = dJ_sgd(theta,X_b[rand_i],y[rand_i])
        theta = theta - learning_rate(cur_iter) * gradient
    return theta

        %%time
        eta = 0.01
        X_b = np.hstack([np.ones((len(X), 1)), X])
        initial_theta = np.zeros(X_b.shape[1])
        # 随机的检查了3分之一个样本总量的样本
        _theta = sgd(X_b, y, initial_theta, n_iters=len(X_b)//3)
        # 输出 CPU times: user 318 ms, sys: 5.22 ms, total: 323 ms
        # Wall time: 337 ms
        # _theta: array([3.03182269, 3.93118623])

5.3 随机梯度下降法的封装和测试

    def fit_sgd(self, X_train, y_train, n_iters=5, t0=5, t1=50):
        """
        根据训练数据集X_train, y_train, 使用随机梯度下降法训练Linear Regression模型
        :param X_train:
        :param y_train:
        :param n_iters: 在随机梯度下降法中，n_iters代表所有的样本会被看几圈
        :param t0:
        :param t1:
        :return:
        """
        assert X_train.shape[0] == y_train.shape[0], \
            "the size of X_train must be equal to the size of y_train"
        assert n_iters >= 1

        def dJ_sgd(theta, X_b_i, y_i):
            """
            去X_b,y 中的随机一个元素进行导数公式的计算
            :param theta:
            :param X_b_i:
            :param y_i:
            :return:
            """
            return X_b_i * (X_b_i.dot(theta) - y_i) * 2.

        def sgd(X_b, y, initial_theta, n_iters, t0=5, t1=50):

            def learning_rate(t):
                """
                计算学习率，t1 为了减慢变化速度，t0为了增加随机性
                :param t: 第t次循环
                :return:
                """
                return t0 / (t + t1)

            theta = initial_theta
            m = len(X_b)

            for cur_iter in range(n_iters):
                # 对X_b进行一个乱序的排序
                indexes = np.random.permutation(m)
                X_b_new = X_b[indexes]
                y_new = y[indexes]

                # 对整个数据集看一遍
                for i in range(m):
                    gradient = dJ_sgd(theta, X_b_new[i], y_new[i])
                    theta = theta - learning_rate(cur_iter * m + i) * gradient

            return theta

        X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
        initial_theta = np.random.randn(X_b.shape[1])
        self._theta = sgd(X_b, y_train, initial_theta, n_iters, t0, t1)

        self.interception_ = self._theta[0]
        self.coef_ = self._theta[1:]

        return self

模拟数据进行测试

5.3-1

真实数据波士顿房价进行测试

5.3-2

5.4 使用Sklearn中的 随机梯度下降法

5.4-1
需要注意的是sklearn中的梯度下降法比我们自己的算法要复杂的多，性能和计算准确度上都比我们的要好，我们的算法只是用来演示过程，具体生产上的使用还是应该使用Sklearn提供的

6 梯度下降法 的调试

6.1 梯度下降法调试的原理

可能我们计算出梯度下降法的公式，并使用python编程实现，预测的过程中程序并没有报错，但是可能我们需要求的梯度的结果是错误的，这个时候需要怎么样去调试发现错误呢。

首先以二维坐标平面为例，一个点（O）的导数就是曲线在这个点的切线的斜率，在这个点两侧各取一个点（AB），那么AB两点对应的直线的斜率应该大体等于O的切线的斜率，并且这A和B的距离越近，那么两条直线的斜率就越接近
事实上，这也正是导数的定义，当函数y=f(x)的自变量x在一点x0上产生一个增量Δx时，函数输出值的增量Δy与自变量增量Δx的比值在Δx趋于0时的极限a如果存在，a即为在x0处的导数，记作f’(x0)或df(x0)/dx
6-1

扩展到多维维度则如下

6-2

梯度下降法调试的实现

np.random.seed(666)
X = np.random.normal(size=(1000,10))
X_b = np.hstack([np.ones((len(X),1)),X])

# 真实的θ值
true_theta = np.arange(1,12,dtype=float)
# np.random.normal(size=1000) 添加噪音
y = X_b.dot(true_theta) + np.random.normal(size=1000)

# 实现J(θ)函数
def J(theta,X_b,y):
    try:
        return np.sum((y-X_b.dot(theta))**2)/len(X_b)
    except:
        return float('inf')
    
# 实现数学推导出的dJ(θ)
def d_J_main(theta,X_b,y):
    return X_b.T.dot(X_b.dot(theta) - y) * 2. /len(X_b)

# 实现debug模式的dJ(θ)
def d_J_debug(theta,X_b,y,epsilon=0.01):
    res = np.empty(len(theta))
    for i in range(len(theta)):
        theta_1 = theta.copy()
        theta_1[i] += epsilon
        theta_2 = theta.copy()
        theta_2[i] -= epsilon
        res[i] = (J(theta_1,X_b,y)-J(theta_2,X_b,y))/(2*epsilon)
    return res

# 批量梯度下降法，d_J为求导函数，作为一个参数传入，用于切换求导策略
def gradient_descent(d_J,X_b, y, initial_theta, eta, n_iters=1e4, epsilon=1e-8):
            theta = initial_theta
            i_iters = 0

            while i_iters < n_iters:
                gradient = d_J(theta, X_b, y)
                last_theta = theta
                theta = theta - eta * gradient

                if abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon:
                    break

                i_iters += 1

            return theta

X_b = np.hstack([np.ones((len(X), 1)), X])
initial_theta = np.zeros(X_b.shape[1])
eta = 0.01
# 使用d_J_debug调试模式求出theta
%time theta = gradient_descent(d_J_debug,X_b, y, initial_theta, eta)
print(theta)
# 使用数学解求出theta
%time theta = gradient_descent(d_J_main,X_b, y, initial_theta, eta)
print(theta)

# 输出结果
CPU times: user 531 ms, sys: 214 ms, total: 745 ms
Wall time: 613 ms
[ 0.94575233  1.98082712  3.06882065  3.94835863  4.97139932  5.9859077
  7.01077392  7.99250414  8.99151383  9.97525811 10.99758484]
CPU times: user 67 ms, sys: 27.6 ms, total: 94.6 ms
Wall time: 76.7 ms
[ 0.94575233  1.98082712  3.06882065  3.94835863  4.97139932  5.9859077
  7.01077392  7.99250414  8.99151383  9.97525811 10.99758484]

由此可以看出，我们的d_J_debug和d_J_main的结果是相近的，所以我们的d_J_main的数学推导是没问题的。
我们可以在真正的机器学习之前，先使用d_J_debug这种调试方式来验证一下我们的d_J_main的结果是否正确，然后再进行机器学习。

d_J_debug是通用的，可以放在任何求导的debug过程中，所以可以作为我们机器学习的工具箱来使用

7.梯度下降法的总结

7.1 小批量

  • 批量梯度下降法
  • 随机梯度下降法
    下面来看下二者的对比
维度批量梯度下降法随机梯度下降法
计算方式每次对所有的样本看一遍才可以计算出梯度每一次只需观察一个样本
速度慢快
稳定性高，一定可以先向损失函数下降的方式前进低，每一次的方式不确定，甚至向反方向前进

综合二者的优缺点，有一种新的梯度下降法

7-1
小批量梯度下降法：即，我们每一次不看全部样本那么多，也不是只看一次样本那么少，每次只看k个样本
对于小批量梯度下降法，由多了一个超参数

def fit_lit_sgd(self, X_train, y_train, n_iters=5, t0=5, t1=50,k=10):
        """
        根据训练数据集X_train, y_train, 使用随机梯度下降法训练Linear Regression模型
        :param X_train:
        :param y_train:
        :param n_iters: 在随机梯度下降法中，n_iters代表所有的样本会被看几圈
        :param t0:
        :param t1:
        :param k: 小批量随机下降法的超参数k
        :return:
        """
        assert X_train.shape[0] == y_train.shape[0], \
            "the size of X_train must be equal to the size of y_train"
        assert n_iters >= 1

        def dJ_sgd(theta, X_b_k, y_k):
            """
            去X_b,y 中的随机选择k个元素进行导数公式的计算
            :param theta:
            :param X_b_i:
            :param y_i:
            :return:
            """
            return np.sum((X_b_k * (X_b_k.dot(theta) - y_k) ))* 2/len(X_b_k).

        def sgd(X_b, y, initial_theta, n_iters, t0=5, t1=50):

            def learning_rate(t):
                """
                计算学习率，t1 为了减慢变化速度，t0为了增加随机性
                :param t: 第t次循环
                :return:
                """
                return t0 / (t + t1)

            theta = initial_theta
            m = len(X_b)

            for cur_iter in range(n_iters):
                # 每次看k个元素
                i =0
                while i < m:
                    X_b_new = X_b[i:i+k]
                    y_new = y[i:i+k]
                    gradient = dJ_sgd(theta, X_b_new, y_new)
                    theta = theta - learning_rate(cur_iter * m + i+k) * gradient
                    i = i+k

            return theta

        X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
        initial_theta = np.random.randn(X_b.shape[1])
        self._theta = sgd(X_b, y_train, initial_theta, n_iters, t0, t1)

        self.interception_ = self._theta[0]
        self.coef_ = self._theta[1:]

        return self

7.2 随机

随机梯度下降法的优点
7.2-1

7.3 梯度上升法

7.3-1

7.3-2

7.3-3

cmvaxx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
梯度下降法（Gradient descent）
pochy的博客
10-17 1740
1. 梯度下降法简介 1-1   以下是定义了一个损失函数以后，参数theta对应的损失函数J的值对应的示例图，我们需要找到使得损失函数值J取得最小值对应的theta（这里是二维平面，也就是我们的参数只有一个） 在直线方程中，导数代表斜率 在曲线方程中，导数代表切线斜率 导数代表theta单位变化时，J相应的变化   1-2   1-3   η太小，会减慢收敛学习速...
机器学习数据预处理——降维
woor_的博客
01-15 4132
引言   在机器学习的训练过程中，总是会碰到样本大、特征多的数据集。而这些数据集里面的数据有些是用处很小甚至完全无用的。如果一组数据中的无用数据占比较大时，一方面会使得模型的训练时间边长，另一方面模型容易出现欠拟合现象；而如果一组数据中作用较小的数据，即在训练中不能较好体现数据集中样本特征的数据，这类数据占比较大时，除了会提升模型训练的时间以外，还容易引起模型的过拟合现象。   针对这种情况，我们需要对这组数据集进行一个数据的预处理，其主要的方法有降噪、特征筛选以及降维处理，而这次主要讲解如何进行降维处理以
Python3入门机器学习 - 梯度下降法
weixin_34008805的博客
02-28 201
梯度下降是迭代法的一种,可以用于求解最小二乘问题(线性和非线性都可以)。在求解机器学习算法的模型参数，即无约束优化问题时，梯度下降（Gradient Descent）是最常采用的方法之一，另一种常用的方法是最小二乘法。在求解损失函数的最小值时，可以通过梯度下降法来一步步的迭代求解，得到最小化的损失函数和模型...
机器学习中的降维算法和梯度下降法
CDA数据分析师
03-18 414
机器学习中有很多算法都是十分经典的，比如说降维算法以及梯度下降法，这些方法都能够帮助大家解决很多问题，因此学习机器学习一定要掌握这些算法，而且这些算法都是比较受大家欢迎的。在这篇文章中我们就给大家重点介绍一下降维算法和梯度下降法。 降维算法 首先，来说一说降维算法，降维算法是一种无监督学习算法，其主要特征是将数据从高维降低到低维层次。在这里，维度其实表示的是数据的特征...
【机器学习】梯度下降算法原理和实现
kuangd_1992的博客
09-25 2173
梯度下降是许多机器学习模型中都会直接或间接使用的算法。
机器学习中的梯度下降算法
最新发布
05-28
我们使用最小二乘法，能够直接计算损失函数最小值时的参数值，但是，最小二乘法有使用的限制条件，在大多数机器学习的使用场景之下，我们会选择梯度下降的方法来计算损失函数的极小值，首先梯度下降算法的目标仍然是...
机器学习 之 梯度下降
12-21
机器学习中的梯度下降是优化模型参数的一种基本算法，它广泛应用于各种模型的训练，例如线性回归、逻辑回归和神经网络等。梯度下降的核心思想是通过不断迭代更新模型参数，使其朝着损失函数（成本函数）下降最快的...
机器学习之梯度下降法
01-06
梯度下降法（Gradient descent）是一个一阶最优化算法。 要使用梯度下降法找到一个函数的局部极小值，必须向函数上当前点对应梯度（或者是近似梯度）的反方向的规定步长距离点进行迭代搜索。如果相反地向梯度正方向...
机器学习-梯度下降算法
12-04
机器学习-梯度下降算法 梯度下降算法是机器...梯度下降算法是一种重要的机器学习算法，广泛应用于各种机器学习模型的优化问题中。但是，需要根据具体情况选择合适的算法和参数设置，以保证算法的收敛速度和准确性。
机器学习中梯度下降的几种方式
01-06
批量梯度下降 定义：批量梯度下降的一次训练喂入训练集中的所有数据，使用所有数据来更新权重，也就是batch_size=训练集大小 算法 3. 特点 求和中的运算都是向量运算 参数的更新需要计算所有数据的平均值之后才能...
梯度下降法
热门推荐
sikh_0529的博客
09-06 1万+
我们要学习一个机器学习的重要方法——梯度下降法（Gradient Descent）梯度下降法并不是一个机器学习的算法，它既不能解决回归问题，也不能解决分类问题。那么它是什么呢？梯度下降是一种基于搜索的最优化的方法，它的目标是用于优化一个目标函数。在机器学习中，梯度下降法的作用就是：最小化一个损失函数。
机器学习(7)--梯度下降法（GradientDescent）的简单实现
雨落那秋林
02-06 1804
曾经在  机器学习(1)--神经网络初探  详细介绍了神经网络基本的算法，在该文中有一句 weights[i] += 0.2 * layer.T.dot(delta) #0.2学习效率，应该是一个小于0.5的数，同时在  tensorflow实例(2)--机器学习初试 篇文章中用tensorflow实现上述的神经网络算法，该文中也有一句 train=tf.train.GradientDe
机器学习——gradient descent
qq_46141221的博客
06-03 135
机器学习——梯度下降法线性回归算法 主要目的: ​ 通过线性回归算法，根据已知的数据集进行训练得出一条较吻合的曲线。 相关概念： ​ 回归曲线：可以直观呈现出数据集相关的关系，并可以进行预测。 ​ 梯度下降法： ​ cost function: 回归算法是一种监督学习算法，会有响应的数据与预测数据进行比对，损失函数就是一种预测数据与实际数据偏差的表征。 实验步骤： 1：根据数据集画出对应的图 2：求出它的近似曲线： ​ 根据图片可以看出这是一个线性函数：我们可以先假设它为 h(x)=θ0+θ1x h(x
数据分析第九篇：梯度下降详解
weixin_30246221的博客
12-07 319
1什么是梯度下降法 是一种基于搜索的最优法方法 下面这个图是在一维方向的求导，但是在多维的我们需要对各个维度求导，然后进行一个合并。多维中叫做梯度。 在直线上，导数代表斜率 在曲线方程中，导数代表切线斜率。也代表theta单位变化时，J相应的变化 在这一点上，导数为负值，当theta增加，J是减小的。导数可以代表方向，对应J增大的方向，我们需要J减小的话，就需要向导数的反方...
机器学习之梯度下降法(Gradient Descent)
ysl的博客
08-07 7025
1.梯度下降法 首先梯度下降法不是一个机器学习算法，而是一种基于搜索的最优化方法。它的作用是最小化一个损失函数。梯度上升法则是最大化一个效用函数。 导数可以代表J 增大的方向，如上图一点导数为负值，说明J增大的方向是沿着X轴负方向。 代表移动的步长，一直移动到导数为0.     模拟梯度下降法： """模拟梯度下降法""" import numpy as np im...
gradient descent修正
qq_46141221的博客
11-02 151
线性回归算法 主要目的: ​ 通过线性回归算法，根据已知的数据集进行训练得出一条较吻合的曲线。 相关概念： ​ 回归曲线：可以直观呈现出数据集相关的关系，并可以进行预测。 ​ 梯度下降法： ​ cost function: 回归算法是一种监督学习算法，会有响应的数据与预测数据进行比对，损失函数就是一种预测数据与实际数据偏差的表征。 实验步骤： 1：根据数据集画出对应的图 # Part two plotting def plotData(x, y): plt.plot(x, y, 'rx', ms='
《deep learning》学习笔记（8）——深度模型中的优化
04-23 8137
https://blog.csdn.net/u011239443/article/details/80046684 机器学习中的算法涉及诸多的优化问题，典型的就是利用梯度下降法(gradient descent)求使损失函数 J(theta) 下降的模型参数 theta 。在深度学习，尤其是深度神经网络的训练和预测中，大的模型往往要花上数天甚至是数月的训练时间，因此虽然模型的优化费事费力，仍然是...
Gradient Descent梯度下降算法代码实现
zn961018的博客
05-01 1154
目录 摘要 梯度下降法原理 使用二次函数简单实现和验证梯度下降 画出梯度下降的过程 学习率对梯度下降快慢的影响 在线性回归模型中使用梯度下降法 Conclusion（总结） 摘要 使用代码实现和验证梯度下降算法 梯度下降法原理 梯度下降，gradient descent(之后将简称GD)，是一种通过迭代找最优的方式一步步找到损失函数最小值的算法，基本算法思路可总结为如下几点： (1) 随机设置一个初始值 (2) 计算损失函数的梯度 (3) 设置步长，步长的长短将会决定梯度下降的速
Python遇见机器学习 ---- 梯度下降法法 Gradient Descent
如切如磋，如琢如磨
03-08 1692
综述 “譬如行远必自迩，譬如登高必自卑。” 本文采用编译器：jupyter 所谓梯度下降算法，本质上来讲并不能将其称作为机器学习算法，但是可以用于很多机器学习解决问题的领域，并且从数学上为我们解决一个复杂的问题提供了一个思路。 回顾上一文中所述线性回归算法的损失函数，我们完全可以使用梯度下降法来最小化，就像日常生活中我们在登山时一定会选择最近的路程，所谓“梯度”其实就是“山”最陡峭的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值