查看: 6508|回复: 1

Python深度学习之初窥神经网络

字体大小: 正常放大

杨利霞

5273 主题	82 听众	17万积分

TA的每日心情

	开心 2021-8-11 17:59

签到天数: 17 天

[LV.4]偶尔看看III

网络挑战赛参赛者

自我介绍: 本人女，毕业于内蒙古科技大学，担任文职专业，毕业专业英语。

群组: 2018美赛大象算法课程

群组: 2018美赛护航培训课程

群组: 2019年数学中国站长建

群组: 2019年数据分析师课程

群组: 2018年大象老师国赛优

电梯直达

1^#

发表于 2020-5-12 11:55 |只看该作者 |倒序浏览

|招呼Ta 关注Ta

Python深度学习之初窥神经网络
本文为第2章开始之前：神经网络背后的数学 (Chapter 2. Before we begin: the mathematical building blocks of neural networks) 的笔记整合。

本文目录：

文章目录

Deep Learning with Python
初窥神经网络
导入MNIST数据集
网络构建
编译
预处理
图形处理
标签处理
训练网络
神经网络的数据表示
认识张量
标量 (0D Tensors)
向量 (1D Tensors)
矩阵 (2D Tensors)
高阶张量
张量的三要素
Numpy张量操作
张量切片：
数据批量
常见数据张量表示
神经网络的“齿轮”: 张量运算
逐元素操作(Element-wise)
广播(Broadcasting)
张量点积(dot)
张量变形(reshaping)
神经网络的“引擎”: 基于梯度的优化
导数(derivative)
梯度(gradient)
随机梯度下降(Stochastic gradient descent)
反向传播算法：链式求导
本文由 CDFMLR 原创，收录于个人主页 https://clownote.github.io。

初窥神经网络

学编程语言从 “Hello World” 开始，学 Deep learning 从 MINST 开始。

MNIST 用来训练手写数字识别，它包含 28x28 的灰度手写图片，以及每张图片对应的标签(0~9的值)。

导入MNIST数据集

# Loading the MNIST dataset in Keras
from tensorflow.keras.datasets import mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
1
2
3
看一下训练集：

print(train_images.shape)
print(train_labels.shape)
train_labels
1
2
3
输出：

(60000, 28, 28)
(60000,)

array([5, 0, 4, ..., 5, 6, 8], dtype=uint8)
1
2
3
4
这是测试集：

print(test_images.shape)
print(test_labels.shape)
test_labels
1
2
3
输出：

(10000, 28, 28)
(10000,)

array([7, 2, 1, ..., 4, 5, 6], dtype=uint8)
1
2
3
4
网络构建

我们来构建一个用来学习 MNIST 集的神经网络：

from tensorflow.keras import models
from tensorflow.keras import layers

network = models.Sequential()
network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28, )))
network.add(layers.Dense(10, activation='softmax'))
1
2
3
4
5
6
神经网络是一个个「层」组成的。
一个「层」就像是一个“蒸馏过滤器”，它会“过滤”处理输入的数据，从里面“精炼”出需要的信息，然后传到下一层。

这样一系列的「层」组合起来，像流水线一样对数据进行处理。
层层扬弃，让被处理的数据，或者说“数据的表示”对我们最终希望的结果越来越“有用”。

我们刚才这段代码构建的网络包含两个「Dense 层」，这么叫是因为它们是密集连接（densely connected）或者说是全连接的。

数据到了最后一层（第二层），是一个 10路的 softmax 层。
这个层输出的是一个数组，包含 10 个概率值（它们的和为1），这个输出「表示」的信息就对我们预测图片对应的数字相当有用了。
事实上这输出中的每一个概率值就分别代表输入图片属于10个数字（0～9）中的一个的概率！

编译

接下来，我们要编译这个网络，这个步骤需要给3个参数：

损失函数：评价你这网络表现的好不好的函数
优化器：怎么更新（优化）你这个网络
训练和测试过程中需要监控的指标，比如这个例子里，我们只关心一个指标 —— 预测的精度
network.compile(loss="categorical_crossentropy",
            optimizer='rmsprop',
            metrics=['accuracy'])
1
2
3
预处理

图形处理

我们还需要处理一下图形数据，把它变成我们的网络认识的样子。

MNIST 数据集里的图片是 28x28 的，每个值是属于 [0, 255] 的 uint8。
而我们的神经网络想要的是 28x28 的在 [0, 1] 中的 float32。

train_images = train_images.reshape((60000, 28 * 28))
train_images = train_images.astype('float32') / 255

test_images = test_images.reshape((10000, 28 * 28))
test_images = test_images.astype('float32') / 255
1
2
3
4
5
标签处理

同样，标签也是需要处理一下的。

from tensorflow.keras.utils import to_categorical

train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)
1
2
3
4
训练网络

network.fit(train_images, train_labels, epochs=5, batch_size=128)
1
输出：

Train on 60000 samples
Epoch 1/5
60000/60000 [==============================] - 3s 49us/sample - loss: 0.2549 - accuracy: 0.9254
Epoch 2/5
60000/60000 [==============================] - 2s 38us/sample - loss: 0.1025 - accuracy: 0.9693
Epoch 3/5
60000/60000 [==============================] - 2s 35us/sample - loss: 0.0676 - accuracy: 0.9800
Epoch 4/5
60000/60000 [==============================] - 2s 37us/sample - loss: 0.0491 - accuracy: 0.9848
Epoch 5/5
60000/60000 [==============================] - 2s 42us/sample - loss: 0.0369 - accuracy: 0.9888

<tensorflow.python.keras.callbacks.History at 0x13a7892d0>
1
2
3
4
5
6
7
8
9
10
11
12
13
可以看到，训练很快，一会儿就对训练集有 98%+ 的精度了。

再用测试集去试试：

test_loss, test_acc = network.evaluate(test_images, test_labels, verbose=2) # verbose=2 to avoid a looooong progress bar that fills the screen with '='. https://github.com/tensorflow/tensorflow/issues/32286
print('test_acc:', test_acc)
1
2
输出：

10000/1 - 0s - loss: 0.0362 - accuracy: 0.9789
test_acc: 0.9789
1
2
我们训练好的网络在测试集下的表现并没有之前在训练集中那么好，这是「过拟合」的锅。

神经网络的数据表示

Tensor，张量，任意维的数组（我的意思是编程的那种数组）。矩阵是二维的张量。

我们常把「张量的维度」说成「轴」。

认识张量

标量 (0D Tensors)

Scalars，标量是 0 维的张量（0个轴），包含一个数。

标量在 numpy 中可以用 float32 或 float64 表示。

import numpy as np

x = np.array(12)
x
1
2
3
4
输出：

array(12)
1
x.ndim # 轴数（维数）
1
输出：

1
1
向量 (1D Tensors)

Vectors，向量是 1 维张量（有1个轴），包含一列标量（就是搞个array装标量）。

x = np.array([1, 2, 3, 4, 5])
x
1
2
输出：

array([1, 2, 3, 4, 5])
1
x.ndim
1
输出：

1
1
我们把这样有5个元素的向量叫做“5维向量”。
但注意5D向量可不是5D张量！

5D向量：只有1个轴，在这个轴上有5个维度。
5D张量：有5个轴，在每个轴上可以有任意维度。
这个就很迷，这“维度”有的时候是指轴数，有的时候是指轴上的元素个数。

所以，我们最好换种说法，用「阶」来表示轴数，说 5阶张量。

矩阵 (2D Tensors)

Matrices，矩阵是 2 阶张量（2个轴，就是我们说的「行」和「列」），包含一列向量（就是搞个array装向量）。

x = np.array([[5, 78, 2, 34, 0],
            [6, 79, 3, 35, 1],
            [7, 80, 4, 36, 2]])
x
1
2
3
4
输出：

array([[ 5, 78,  2, 34,  0],
   [ 6, 79,  3, 35,  1],
   [ 7, 80,  4, 36,  2]])
1
2
3
x.ndim
1
输出：

2
1
高阶张量

你搞个装矩阵的 array 就得到了3阶张量。

再搞个装3阶张量的 array 就得到了4阶张量，依次类推，就有高阶张量了。

x = np.array([[[5, 78, 2, 34, 0],
            [6, 79, 3, 35, 1],
            [7, 80, 4, 36, 2]],
            [[5, 78, 2, 34, 0],
            [6, 79, 3, 35, 1],
            [7, 80, 4, 36, 2]],
            [[5, 78, 2, 34, 0],
            [6, 79, 3, 35, 1],
            [7, 80, 4, 36, 2]]])
x.ndim
1
2
3
4
5
6
7
8
9
10
输出：

3
1
深度学习里，我们一般就用0～4阶的张量。

张量的三要素

阶数（轴的个数）：3，5，…
形状（各轴维数）：(2, 1, 3)，(6, 5, 5, 3, 6)，…
数据类型：float32，uint8，…
我们来看看 MNIST 里的张量数据：

from tensorflow.keras.datasets import mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

print(train_images.ndim)
print(train_images.shape)
print(train_images.dtype)
1
2
3
4
5
6
输出：

3
(60000, 28, 28)
uint8
1
2
3
所以 train_images 是个8位无符号整数的3阶张量。

打印个里面的图片看看：

digit = train_images[0]

import matplotlib.pyplot as plt

print("image:")
plt.imshow(digit, cmap=plt.cm.binary)
plt.show()
print("label: ", train_labels[0])
1
2
3
4
5
6
7
8
输出：

label: 5
1
Numpy张量操作

张量切片：

my_slice = train_images[10:100]
print(my_slice.shape)
1
2
输出：

(90, 28, 28)
1
等价于：

my_slice = train_images[10:100, :, :]
print(my_slice.shape)
1
2
输出：

(90, 28, 28)
1
也等价于

my_slice = train_images[10:100, 0:28, 0:28]
print(my_slice.shape)
1
2
输出：

(90, 28, 28)
1
选出右下角 14x14 的：

my_slice = train_images[:, 14:, 14:]
plt.imshow(my_slice[0], cmap=plt.cm.binary)
plt.show()
1
2
3
输出：

选出中心处 14x14 的：

my_slice = train_images[:, 7:-7, 7:-7]
plt.imshow(my_slice[0], cmap=plt.cm.binary)
plt.show()
1
2
3
输出：

数据批量

深度学习的数据里，一般第一个轴（index=0）叫做「样本轴」（或者说「样本维度」）。

深度学习里，我们一般不会一次性处理整个数据集，我们一批一批地处理。

在 MNIST 中，我们的一个批量是 128 个数据：

# 第一批
batch = train_images[:128]
# 第二批
batch = train_images[128:256]
# 第n批
n = 12
batch = train_images[128 * n : 128 * (n+1)]
1
2
3
4
5
6
7
所以，在使用 batch 的时候，我们也把第一个轴叫做「批量轴」。

常见数据张量表示

数据

zan