描述#

梯度下降算法是深度学习的一个基础概念，基本思想是利用梯度来尝试寻找使损失函数得到最小值的参数，以达到接近真实未知函数的目的。

本次利用python实现简单函数的梯度下降算法。

目标函数形式为：

$y=wx+b$

损失函数形式为：

$Loss=\sum{(wx + b - y)^2}/N, N为x的数量$

梯度下降的目的：

寻找使 $Loss$ 函数值最小的 $w$ 和 $b$ 。

梯度下降的步骤：

初始化w和b，本文均设置为0
计算当前w和b的梯度 dw 和 db

由 $Loss=\sum{(wx + b - y)^2}/N$ 分别对 w 和 b 求导可得梯度的计算公式

$\frac{dLoss}{dw} = \sum{2 * (wx + b - y) *x} / N$ ，以下简称dw

$\frac{dLoss}{db} = \sum2*(wx+b-y)/N$ ，以下简称db
通过梯度和学习率 ( lr ) 更新w和b

$w = w - lr * dw$

$b = b - lr*db$
重复执行2步，直到循环一定次数或损失满足一定条件
得到最终的 w 和 b 就是梯度下降的结果，可通过损失函数计算当前 w 和 b 的损失来对结果进行评估

实现代码#

1
import random
2

3
def compute_error_for_line_given_points(b, w, points):
4
    '''
5
    计算损失
6

7
    :param b: 偏置
8
    :param w: 权重
9
    :param points: 点
10
    :return: 返回均方差
11
    '''
12

13
    totalError = 0
14
    for index, [x, y] in enumerate(points):
15
        totalError += (y - (w * x + b)) ** 2
16
    return totalError / len(points)
17

18
def step_gradient(b_current, w_current, points, learningRate):
19
    '''
20
    梯度下降
21

22
    :param b_current: 当前偏置
23
    :param w_current: 当前权重
24
    :param points: 点
25
    :param learningRate: 当前学习率
26
    :return: 新偏置 new_b, 新权重 new_w
27
    '''
28

29
    b_gradient = 0
30
    w_gradient = 0
31
    N = len(points)
32

33
    '''
34
    loss = (wx + b - y) ** 2
35
    db = 2(wx + b - y)
36
    dw = 2(wx + b - y) * x
37
    '''
38

39
    # 求累加梯度
40
    for index, [x, y] in enumerate(points):
41
        b_gradient += - 2 * (y - (w_current * x + b_current))
42
        w_gradient += - 2 * (y - (w_current * x + b_current)) * x
43

44
    # 求平均梯度
45
    b_gradient /= N
46
    w_gradient /= N
47

48
    # 梯度下降
49
    new_b = b_current - learningRate * b_gradient
50
    new_w = w_current - learningRate * w_gradient
51

52
    return new_b, new_w
53

54
def gradient_descent_runner(points, b_start, w_start,
55
                            learningRate, epochs):
56
    '''
57
    梯度下降
58

59
    :param points: 点
60
    :param b_start: 初始偏置
61
    :param w_start: 初始权重
62
    :param learningRate: 学习率
63
    :param epochs: 趟数
64
    :return: 最重的b和w
65
    '''
66
    b = b_start
67
    w = w_start
68

69
    for i in range(epochs):
70
        b, w = step_gradient(b, w, points, learningRate)
71

72
    return b, w
73

74
def createPoints(b, w, sX=-1, eX=1, num=10, delta=1):
75
    '''
76
    根据参数生成一些点
77

78
    :param b: 偏置
79
    :param w: 权重
80
    :param sX: x的起始点
81
    :param eX: x的结束点
82
    :param num: 点的个数
83
    :param delta: 随机浮动的范围，从 -delta/2 ~ delta/2
84
    :return: 生成的点
85
    '''
86
    points = []
87
    x = sX
88
    for i in range(num):
89
        y = x * w + b + (random.random() - 0.5) * delta
90
        points.append([x, y])
91
        x += (eX - sX) / num
92

93
    return points
94

95
if __name__ == "__main__":
96
    # 设置目标函数的权重和偏置
97
    b = 4
98
    w = 2
99

100
    # 生成随机点
101
    points = createPoints(b, w, -10, 10, 1000, 1)
102

103
    # 设置参数
104
    b_start = 0
105
    w_start = 0
106
    learningRate = 0.01
107
    epochs = 100
108

109
    # 开始梯度下降
110
    b_final, w_final = gradient_descent_runner(points, b_start, w_start,
111
                                               learningRate, epochs)
112

113
    # 计算损失
114
    loss_final = compute_error_for_line_given_points(b_final, w_final, points)
115

116
    # 最终结果
117
    print("函数为 y = {}x + {}".format(w, b))
118
    print("最终结果：\nb:{} \nw:{}\nloss:{}".format(b_final, w_final, loss_final))

最终结果#

在这里插入图片描述

原文链接：CSDN