深度学习基础篇_深度学习分几层

1. 深度学习基本介绍和基本应用

1.1 神经网络与深度学习

神经网络由输入层，隐藏层，输出层组成，其中的隐藏层数量大约在5到6层，而深度学习可以理解成与神经网络相近的东西，但深度学习的隐藏层层数可以很多层。

1.2 深度学习的基本应用

1.3 深度学习的知识框架

2. 深度学习的发展背景和人物介绍

3. 机器学习基础

3.1 训练数据，难证数据，测试数据

3.2 监督学习，无监督学习，半监督学习

数据带有标签

数据不带标签

3.3 回归，分类，聚类

对没有标签的数据，根据数据的属性和分布，对数据进行归类。



首先要做的是分析具体的情况是属于哪一种情况，是回归、分类还是聚类，然后选择不同的算法对数据进行处理。
有的算法功能可是多样的，有的可能功能是单一的。

4. 单层感知器

这种结构中将第一种结构中的偏置b放到了神经元的外边，也就是x0=1，x0 * w0相当于b，并最终会被加和一起。


y=sign(1*1)=1=t，这里的t代表标签的值，此处输出值y=t，表示输出值与标签值一样，模型训练完成。



也就是模型停止训练的条件。

5. 单层感知器应用案例

神经元的输入节点数 = 待分类数据的维度数 + 1（这里是偏置）

import numpy as np
import matplotlib.pyplot as plt

# 定义输入数据
X = np.array([[1, 3, 3],
              [1, 4, 3],
              [1, 1, 1],
              [1, 2, 1]])
# 定义标签
T = np.array([[1],
              [1],
              [-1],
              [-1]])
# 权值初始化，生成3行1列的在[0, 1]之间的随机数
W = np.random.random([3, 1])
# 学习率设置
lr = 0.1
# 神经网络输出
Y = 0

# 更新权值的函数
def train():
    global X, Y, W, lr, T
    # 同时计算4个数据的预测值，Y.shape=(4, 1)
    Y = np.sign(np.dot(X, W))
    # T-Y得到4个标签值与预测值的误差E，E.shape=(4, 1)
    E = T - Y
    # 计算权值的变化
    delta_W = lr * (X.T.dot(E)) / X.shape[0]
    # 更新权值
    W = W + delta_W

# 训练模型
for i in range(100):
    # 更新权值
    train()
    # 打印当前训练次数
    print('epoch: ', i + 1)
    # 当前权值
    print('weight: ', W)
    # 计算当前输出
    Y = np.sign(np.dot(X, W))
    # 因为Y和T中各有4个数，all()表示当4个值对应相等时，才为真
    if (Y == T).all():
        print('Finishi!')
        # 跳出循环
        break

# 画图
# 正样本的xy坐标
x1 = [3, 4]
y1 = [3, 3]
# 负样本的xy坐标
x2 = [1, 2]
y2 = [1, 1]
# 定义分类边界线的斜率和截距
k = -W[1] / W[2]
d = -W[0] / W[2]
# 设定两个点
xdata = (0, 5)
# 通过两点来确定一条直线
plt.plot(xdata, xdata * k + d, 'r')
# 用蓝色的点画正样本
plt.scatter(x1, y1, c='b')
# 用黄色的点画负样本
plt.scatter(x2, y2, c='y')

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

6. 线性神经网络

也可直接将 np.sign() 函数去掉。
线性神经网络与单层感知器的区别：

1. 激活函数不同，单层感知器的激活函数为 np.sign()；线性神经网络的激活函数可以省略
2. 结束训练的方式不同，单层感知器当输出 = 标签时，训练结束，而线性神经网络不能采用这种方法，因为其输出有多种值
3. 分类效果不同，单层感知器在分界线将不同的点分开时，就停止训练，而线性神经网络会继续训练直到到达设置的训练次数，当训练次数足够的情况下，线性神经网络的分类效果会比单层神经网络的要好。（可对比两种方式的输出结果）

import numpy as np
import matplotlib.pyplot as plt

# 定义输入数据
X = np.array([[1, 3, 3],
              [1, 4, 3],
              [1, 1, 1],
              [1, 2, 1]])
# 定义标签
T = np.array([[1],
              [1],
              [-1],
              [-1]])
# 权值初始化，生成3行1列的在[0, 1]之间的随机数
W = np.random.random([3, 1])
# 学习率设置
lr = 0.1
# 神经网络输出
Y = 0

# 更新权值的函数
def train():
    global X, Y, W, lr, T
    # 同时计算4个数据的预测值，Y.shape=(4, 1)
    Y = np.dot(X, W)
    # T-Y得到4个标签值与预测值的误差E，E.shape=(4, 1)
    E = T - Y
    # 计算权值的变化
    delta_W = lr * (X.T.dot(E)) / X.shape[0]
    # 更新权值
    W = W + delta_W

# 训练模型
for i in range(100):
    # 更新权值
    train()

# 画图
# 正样本的xy坐标
x1 = [3, 4]
y1 = [3, 3]
# 负样本的xy坐标
x2 = [1, 2]
y2 = [1, 1]
# 定义分类边界线的斜率和截距
k = -W[1] / W[2]
d = -W[0] / W[2]
# 设定两个点
xdata = (0, 5)
# 通过两点来确定一条直线
plt.plot(xdata, xdata * k + d, 'r')
# 用蓝色的点画正样本
plt.scatter(x1, y1, c='b')
# 用黄色的点画负样本
plt.scatter(x2, y2, c='y')

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

7. delta学习规则和梯度下降法

参数说明：
t：标签值
y：预测值
1/2：这里只是为了求导时能够与二次方的导数相约掉

8. BP网络介绍

BP网络解决了单层神经网络不能解决非线性问题，BP网络有多个隐藏层

学习信号：
最后一层的学习信号采用

其他层采用

权重变化还是采用delta学习规则
运算的时候，必须先算最后一个权值，再往前算。

8.1 BP神经网络处理异或问题

import numpy as np

# 输入数据
X = np.array([[1, 0, 0],
              [1, 0, 1],
              [1, 1, 0],
              [1, 1, 1]])
# 标签
Y = np.array(([[0],
               [1],
               [1],
               [0]]))
# 3-10-1，使权值范围在-1到1
V = np.random.random([3, 10]) * 2 - 1
W = np.random.random([10, 1]) * 2 - 1
# 学习率
lr = 0.1
# 激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
# 激活函数的导数
def dsigmoid(x):
    return x * (1 - x)
# 权值调整函数
def update():
    global V, W
    # 求每一层的输出
    L1 = sigmoid(np.dot(X, V))
    L2 = sigmoid(np.dot(L1, W))
    # 求每一层的学习信号
    L2_delta = (Y-L2) * dsigmoid(L2)
    L1_delta = L2_delta.dot(W.T) * dsigmoid(L1)
    # 求每一层权值的变化
    delta_W = lr * L1.T.dot(L2_delta)
    delta_V = lr * X.T.dot(L1_delta)
    # 改变权值
    W = W + delta_W
    V = V + delta_V

for i in range(10001):
    # 更新权值
    update()
    if i % 500 == 0:
        L1 = sigmoid(np.dot(X, V))
        L2 = sigmoid(np.dot(L1, W))
        loss = np.mean(np.square(Y-L2) / 2)
        print('loss:', loss)

L1 = sigmoid(np.dot(X, V))
L2 = sigmoid(np.dot(L1, W))
print(L2)

def judge(x):
    if x >= 0.5:
        return 1
    else:
        return 0
# L2中有4个值，map()会将L2中的4个值放入judge()中，然后输出对应的值
for i in map(judge, L2):
    print(i)

'''
loss: 0.12785375779914804
loss: 0.12396979564241487
loss: 0.11987341405279772
loss: 0.10135122357504125
loss: 0.04976727174360503
loss: 0.019266299745214797
loss: 0.009835163857697369
loss: 0.0061676145223672285
loss: 0.004359101584531972
loss: 0.0033175038957391776
loss: 0.002652375969255136
loss: 0.00219582300330277
loss: 0.0018653879267179771
loss: 0.0016163891081790618
loss: 0.0014227237218564803
loss: 0.0012682131268280208
loss: 0.0011423400043669095
loss: 0.001037993966363435
loss: 0.0009502077739702453
loss: 0.000875413578922762
loss: 0.0008109868142149247
[[0.03697778]
 [0.95948157]
 [0.95978422]
 [0.04314495]]
0
1
1
0
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

8.2 BP神经网络实现手写数字识别

import numpy as np
from sklearn.datasets import load_digits
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix
import matplotlib.pyplot as plt

# 载入数据
digits = load_digits()
# 数据
X = digits.data

# 标签
y = digits.target

# 64-100-10 因为一张图片有64个像素，所以输入层为64个神经元，
# 隐藏层一般比输入层多一点，输出层10，因为有10个分类
# 定义输入层到隐藏层之间的权值矩阵
V = np.random.random([64, 100]) * 2 - 1
# 定义隐藏层到输出层之间的权值矩阵
W = np.random.random([100, 10]) * 2 - 1

# 数据切分
# 默认3/4为训练集，1/4为测试集
X_train, X_test, y_train, y_test = train_test_split(X, y)

# 标签二值化
'''
例如：
0->1000000000
3->0001000000
9->0000000001
'''
labels_train = LabelBinarizer().fit_transform(y_train)
# print(y_train[: 5])
# print(labels_train[: 5])
'''
[3 7 8 2 4]
[[0 0 0 1 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 1 0 0]
 [0 0 0 0 0 0 0 0 1 0]
 [0 0 1 0 0 0 0 0 0 0]
 [0 0 0 0 1 0 0 0 0 0]]
'''

# 激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 激活函数的导数
def dsigmoid(x):
    return x * (1 - x)

# 训练模型
def train(X, y, steps=10000, lr=0.1):
    global V, W
    for n in range(steps + 1):
        # 随机产生一个整数,数值在(0, X的行数)
        i = np.random.randint(X.shape[0])
        # 获取一个数据
        x = X[i]
        # 把数据转为二维，因为后边要做矩阵乘法，所以需要二维的矩阵
        x = np.atleast_2d(x)
        # BP算法的公式
        # 计算隐藏层的输出
        L1 = sigmoid(np.dot(x, V))
        # 计算输出层的输出
        L2 = sigmoid(np.dot(L1, W))
        # 计算输出层学习信号
        L2_delta = (y[i] - L2) * dsigmoid(L2)
        # 计算隐藏层的学习信号
        L1_delta = L2_delta.dot(W.T) * dsigmoid(L1)
        # 更新权值
        W += lr * L1.T.dot(L2_delta)
        V += lr * x.T.dot(L1_delta)

        # 每训练1000次预测一次准确率
        if n % 1000 == 0:
            output = predict(X_test)
            # 获取最大值所在的位置
            predictions = np.argmax(output, axis=1)
            # 用预测值与标签值进行对比
            acc = np.mean(np.equal(predictions, y_test))
            print('steps:', n, 'accuracy:', acc)

def predict(x):
    # 计算隐藏层的输出
    L1 = sigmoid(np.dot(x, V))
    # 计算输出层的输出
    L2 = sigmoid(np.dot(L1, W))
    return L2

train(X_train, labels_train, 30000)
'''
steps: 0 accuracy: 0.1711111111111111
steps: 1000 accuracy: 0.5422222222222223
steps: 2000 accuracy: 0.7222222222222222
steps: 3000 accuracy: 0.7555555555555555
steps: 4000 accuracy: 0.8844444444444445
steps: 5000 accuracy: 0.8933333333333333
steps: 6000 accuracy: 0.9377777777777778
steps: 7000 accuracy: 0.9311111111111111
steps: 8000 accuracy: 0.9466666666666667
steps: 9000 accuracy: 0.9422222222222222
steps: 10000 accuracy: 0.9511111111111111
steps: 11000 accuracy: 0.96
steps: 12000 accuracy: 0.9644444444444444
steps: 13000 accuracy: 0.9733333333333334
steps: 14000 accuracy: 0.9666666666666667
steps: 15000 accuracy: 0.96
steps: 16000 accuracy: 0.9666666666666667
steps: 17000 accuracy: 0.9644444444444444
steps: 18000 accuracy: 0.9666666666666667
steps: 19000 accuracy: 0.9644444444444444
steps: 20000 accuracy: 0.9711111111111111
steps: 21000 accuracy: 0.9733333333333334
steps: 22000 accuracy: 0.9733333333333334
steps: 23000 accuracy: 0.9711111111111111
steps: 24000 accuracy: 0.9822222222222222
steps: 25000 accuracy: 0.9733333333333334
steps: 26000 accuracy: 0.9711111111111111
steps: 27000 accuracy: 0.9755555555555555
steps: 28000 accuracy: 0.9711111111111111
steps: 29000 accuracy: 0.9688888888888889
steps: 30000 accuracy: 0.9711111111111111
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

8.3 使用sklearn完成手写数字识别

from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report


digits = load_digits()
x_data = digits.data
y_data = digits.target

# 数据拆分
x_train, x_test, y_train, y_test = train_test_split(x_data, y_data)

# 构建模型，2个隐藏层，第1个隐藏层100个神经元，第2隐藏层50个神经元，训练500个周期
mlp = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=500)
mlp.fit(x_train, y_train)

predictions = mlp.predict(x_test)
print(classification_report(y_test, predictions))

'''
              precision    recall  f1-score   support

           0       0.98      0.95      0.97        44
           1       0.91      1.00      0.96        43
           2       1.00      1.00      1.00        46
           3       0.98      1.00      0.99        41
           4       0.96      0.96      0.96        51
           5       0.98      1.00      0.99        50
           6       1.00      1.00      1.00        44
           7       0.98      1.00      0.99        42
           8       0.98      0.88      0.92        48
           9       1.00      0.98      0.99        41

    accuracy                           0.98       450
   macro avg       0.98      0.98      0.98       450
weighted avg       0.98      0.98      0.98       450
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38