深度学习初体验

第1关：什么是神经网络

第一题

神经网络中也有神经元，这些神经元也会与其他神经元相连接，这样就形成了神经网络，而且这种网络我们称之为全连接网络。如下图所示(方块表示神经元):

从图可以看出，神经网络由一层一层的神经元所构成的，并且不同的层有不同的名字。其中输入层表示用来接收数据输入的一组神经元。输出层表示用来输出的一组神经元。隐藏层表示介于输入层与输出层之间的一组神经元。

第二题

如果我们搭积木搭得很高就变成了高楼大厦，同样，如果我们神经网络的层数比较多，我们就成为这样的神经网络为深层神经网络。如果我们用深层神经网络来完成我们想要的功能，我们就叫它为深度学习。

第三题

ReLU（11）=max（0，11）=11

第四题

如果我们神经网络的层数比较多，我们就成为这样的神经网络为深层神经网络。如果我们用深层神经网络来完成我们想要的功能，我们就叫它为深度学习。

含有1层隐藏层的神经网络层数太少，并不是深层神经网络。

第2关：反向传播

第一，二题

神经网络的训练过程就是不断地寻找合适的 W 和 b 来让预测输出与真实标签之间差异最小的过程。那么我们可以将训练过程拆开来看，首先我们需要能够衡量预测输出和真实标签之间的差异，其次我们需要能够不断地优化 W 和 b 使得预测输出与真实标签之间地差异变小。

首先，想要衡量差异，我们可以将预测输出和真实标签输入到一个函数中，然后通过这个函数的计算来量化差异的大小。像这种函数我们称之为损失函数。损失函数的种类有很多，比如面对分类问题时，通常使用交叉熵损失、面对回归问题时通常使用均方误差等。总之可以看成是一个能够量化差异的黑盒子，而且量化出的差异值越小，代表我们的神经网络的预测输出越准确。

其次，我们需要找出 W 和 b 来让差异最小，这个时候我们会使用梯度下降算法来迭代更新 W 和 b 。梯度下降算法的思想是，让 W 和 b 朝着让差异值变小的大体方向来更新，而大体方向怎样获取，就需要计算 W 和 b 对于损失函数的偏导(梯度)。但由于计算 W 和 b 对于损失函数的偏导需要知道 W 和 b 对于神经元中线性计算部分的偏导和线性计算部分对于损失函数的偏导。所以就有了反向传播算法。

第三题

神经网络和其他机器学习算法一样，同样有训练和预测的过程。如果用一句话来概括的话就是预测过程为前向传播的过程，训练过程为重复前向传播加反向传播的过程。

第3关：动手实现CNN识别手写数字

想要 add 一层卷积层，代码如下：

from keras.layers import Conv2D
model = Sequential()
'''
16表示该卷积层有16个卷积核
kernel_size=3表示卷积核的大小为3*3
activation='relu'表示卷积层的激活函数是relu
input_shape=[IMAGE_HEIGHT, IMAGE_WIDTH, 3]表示待卷积图像为32*32的3通道图像
'''
model.add(Conv2D(16, kernel_size=3, activation='relu', input_shape=[32, 32, 3]))

想要 add 一层最大池化层，代码如下：

from keras.layers import Conv2D
model = Sequential()
'''
pool_size=2表示池化窗口的大小为2*2
'''
model.add(MaxPooling2D(pool_size=2))

想要 add 一层扁平层，代码如下：

from keras.layers import Conv2D
model = Sequential()
'''
卷积或者池化后想要接上全连接层之前需要接入扁平层
'''
model.add(Flatten())

所以，如果想要构建如下结构的卷积神经网络，可以编写如下代码：

# 1.有32个5*5的神经元的卷积层，激活函数为relu，输入的数据为宽28高28的灰度图像
# 2.有64个5*5的神经元的卷积层，激活函数为relu
# 3.最大池化层，池化核大小为2*2
# 4.扁平
# 5.有128个神经元的全连接层，激活函数为relu
# 6.有10个神经元的全连接层，激活函数为softmax
model = Sequential()
model.add(Conv2D(32, (5, 5), activation='relu', input_shape=[28, 28, 1]))
model.add(Conv2D(64, (5, 5), activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(10, activation='softmax'))

完整代码和运行结果如下：

from keras.models import Sequential
from keras.layers import Conv2D, MaxPool2D, Flatten, Dense
import numpy as np
# 设置随机种子
np.random.seed(1447)

def build_model():
    '''
    在Begin-End段中构建出如下结构的卷积神经网络
    1.64个5*5的卷积核组成的卷积层，激活函数为relu
    2.最大池化层，池化核大小为2*2
    3.扁平
    4.128个神经元的全连接层，激活函数为relu
    5.10个神经元的全连接层，激活函数为softmax
    :return: 构建好的模型
    '''
    model = Sequential()
    model.add(Conv2D(32, (5, 5), activation='relu', input_shape=[28, 28, 1]))
    #********* Begin *********#
    model.add(Conv2D(64, (5, 5), activation='relu'))
    model.add(MaxPool2D(pool_size=(2, 2)))
    model.add(Flatten())
    model.add(Dense(128, activation='relu'))
    model.add(Dense(10, activation='softmax'))

    #********* End *********#
    return model

第4关：动手实现RNN分析影评情感

使用 Keras 构建循环神经网络

在 Keras 中想要添加 RNN 的结构非常简单，代码如下：

from keras.layers import Embedding, SimpleRNN, Dense
from keras import Sequential
model = Sequential()
# 对输入的影评进行word embedding，一般对于自然语言处理问题需要进行word embedding
model.add(Embedding(1000, 64))
# 构建一层有40个神经元的RNN层
model.add(SimpleRNN(40))
# 将RNN层的输出接到只有一个神经元全连接层
model.add(Dense(1, activation='sigmoid'))

编程要求

填写 python 代码，在 Begin-End 段中构建出如下结构的循环神经网络：

​ 有 30 个神经元的 SimpleRNN 层；

​ 有 16 个神经元的全连接层，激活函数为 relu；

​ 有 1 个神经元的全连接层，激活函数为 sigmoid

代码如下：

from keras.models import Sequential
from keras.layers import Embedding, SimpleRNN, Dense

def build_model():
    '''
    在Begin-End段中构建如下结构的循环神经网络
    1.有30个神经元的SimpleRNN层
    2.有16个神经元的全连接层，激活函数为relu
    3.有1个神经元的全连接层，激活函数为sigmoid
    :return: 构建好的模型
    '''
    model = Sequential()
    model.add(Embedding(1000, 64))
    #********* Begin *********#
    model.add(SimpleRNN(30))
    model.add(Dense(units=16, activation='relu'))
    
    model.add(Dense(units=1, activation='sigmoid'))
    #********* End *********#
    return model

完整代码和运行结果如下：

from keras.models import Sequential
from keras.layers import Embedding, SimpleRNN, Dense

def build_model():
    '''
    在Begin-End段中构建如下结构的循环神经网络
    1.有30个神经元的SimpleRNN层
    2.有16个神经元的全连接层，激活函数为relu
    3.有1个神经元的全连接层，激活函数为sigmoid
    :return: 构建好的模型
    '''
    model = Sequential()
    model.add(Embedding(1000, 64))
    #********* Begin *********#
    model.add(SimpleRNN(30))
    model.add(Dense(units=16, activation='relu'))
    
    model.add(Dense(units=1, activation='sigmoid'))
    #********* End *********#
    return model

第5关：动手实现猫狗大战

读取图片

读取图片可以使用 OpenCV（ OpenCV 是一个开源的计算机视觉库，许多功能都有 python 接口）的 API 来实现。

想要在 python 中使用 opencv ，首先需要导入 cv2 。

import cv2

导入了 cv2 之后，可以使用 imread 函数来读取图片，其中 filename 是想要读取的图片路径。

img = cv2.imread(filename)

由于训练集中的图片大小不一，所以需要将读取到的图片强制缩放到固定的宽和高。所以需要使用 resize 函数，其中 (32, 32) 的意思是将源图像缩放成宽和高都是 32 个像素的图像。

resized_image = cv2.resize(img, (32, 32))

图像归一化

由于卷积神经网络中的参数是通过梯度下降的方式训练出来的，而图像中的每个像素都可以看成是一个特征，因此对图像中的像素值进行归一化能够提高卷积神经网络在梯度下降时的速度，减少损失的震荡程度。想要对图像进行归一化非常简单，因为 opencv 读取后的图像是使用 numpy 的 ndarray 这一数据结构来表示的，所以归一化只需要使用如下代码即可：

img = img / 255.0

onehot编码

在遍历 train_data 目录中的图片时可以根据图片的名字来确定图片所对应的真实标签（ 0 (猫)，1 (狗)）。但是在使用神经网络训练前，需要对标签进行 onehot 编码处理。

onehot 编码是分类变量作为二进制向量的表示。这首先要求将分类值映射到整数值。然后，每个整数值被表示为二进制向量，除了整数的索引之外，它都是零值，它被标记为 1。

在本次实训中，onehot 编码可以看成把左表转换成右表:

从上图可以看出， onehot 编码是把真实标签中所有可能的结果作为列（数据集中只有猫和狗，所以猫和狗作为列），然后把对应的列填上 1 和 0。比如表格中的第 1 行的图片名是 cat.1.jpg （肯定是猫），所以就在猫那一列填成 1，狗那一列填成 0 。第 3 行的图片名是 dog.1.jpg （肯定是狗），所以就在狗那一列填 1，猫那一列填 0。

想要实现 onehot 编码也很简单，只需要先用 numpy 的 zeros 函数分配好空间（ row 指的是有多少张训练集图片，col 指的是有多少种标签）。

onehot = np.zeros((row, col))

然后根据图片名字在对应的列上填 1 即可（在这里假设 onehot 的第 1 列是猫，第 2 列是狗）。

综上可完成题目中get_train_data(data_path)函数的代码：

def get_train_data(data_path):
    '''
    读取并处理数据
    :return:处理好的图像和对应的one-hot编码
    '''
    images = []
    onehot = np.zeros((500, 2))
    #********* Begin *********#
    for i, img_name in enumerate(os.listdir(data_path)):
        if 'cat' in img_name:
            onehot[i, 0] = 1
        else:
            onehot[i, 1] = 1
        img = cv2.imread(os.path.join(data_path, img_name))
        img = cv2.resize(img, (IMAGE_HEIGHT, IMAGE_WIDTH))
        images.append(np.array(img, "float32") / 255.0)

    #********* End *********#
    return np.array(images), onehot

通过查找img_name里是否出现’cat’来判断图片种类，并进行onehot编码

利用os.path.join(data_path, img_name) 将路径连接起来

利用np.array(img, “float32”) / 255.0将img转为float再除以255.0

实现猫狗分类

处理好数据之后，就可以着手构建模型并训练模型了，如：

model = keras.Sequential()
model.add(Conv2D(32, kernel_size=3, activation='relu', input_shape=[IMAGE_HEIGHT, IMAGE_WIDTH, 3]))
model.add(MaxPooling2D(pool_size=2))
model.add(Conv2D(32, kernel_size=3, activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Flatten())
model.add(Dense(96, activation='relu'))
model.add(Dense(2, activation='softmax'))
model.compile(loss='categorical_crossentropy',    optimizer=keras.optimizers.Adam(lr=0.0001),
              metrics=['accu\fracy'])
model.fit(images, onehot, epochs=20, batch_size=32, verbose=0)

综上完成build_model()函数代码

def build_model():
    '''
    构建模型
    :return:构建好的模型
    '''
    model = keras.Sequential()
    #********* Begin *********#
    model.add(Conv2D(32, kernel_size=3, activation='relu', input_shape=[IMAGE_HEIGHT, IMAGE_WIDTH, 3]))
    model.add(MaxPooling2D(pool_size=2))
    model.add(Conv2D(32, kernel_size=3, activation='relu'))
    model.add(MaxPooling2D(pool_size=2))
    model.add(Flatten())
    model.add(Dense(96, activation='relu'))
    model.add(Dense(2, activation='softmax'))
    #********* End *********#
    return model

完成编译模型代码

#********* Begin *********#
    # 编译模型
    model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(lr=0.0001), metrics=['accuracy'])
    #********* End *********#

完整代码和运行结果如下：

一遍过不了可以多交几遍就能过了。

from keras.layers import Dense, Activation, Flatten, Dropout, Conv2D, MaxPooling2D
import keras
import os
import numpy as np
import cv2

# 设置随机种子
np.random.seed(1447)

IMAGE_HEIGHT = 128
IMAGE_WIDTH = 128


def get_train_data(data_path):
    '''
    读取并处理数据
    :return:处理好的图像和对应的one-hot编码
    '''
    images = []
    onehot = np.zeros((500, 2))
    #********* Begin *********#
    for i, img_name in enumerate(os.listdir(data_path)):
        if 'cat' in img_name:
            onehot[i, 0] = 1
        else:
            onehot[i, 1] = 1
        img = cv2.imread(os.path.join(data_path, img_name))
        img = cv2.resize(img, (IMAGE_HEIGHT, IMAGE_WIDTH))
        images.append(np.array(img, "float32") / 255.0)

    #********* End *********#
    return np.array(images), onehot

def build_model():
    '''
    构建模型
    :return:构建好的模型
    '''
    model = keras.Sequential()
    #********* Begin *********#
    model.add(Conv2D(32, kernel_size=3, activation='relu', input_shape=[IMAGE_HEIGHT, IMAGE_WIDTH, 3]))
    model.add(MaxPooling2D(pool_size=2))
    model.add(Conv2D(32, kernel_size=3, activation='relu'))
    model.add(MaxPooling2D(pool_size=2))
    model.add(Flatten())
    model.add(Dense(96, activation='relu'))
    model.add(Dense(2, activation='softmax'))
    #********* End *********#
    return model


def fit_and_predict(model, train_images, onehot, test_images):
    '''
    训练模型，并对测试图像进行预测
    :param model: 训练好的模型
    :param train_images: 训练集图像
    :param onehot: 训练集的one-hot编码
    :param test_images: 测试集图像
    :return: 预测结果
    '''
    #********* Begin *********#
    # 编译模型
    model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(lr=0.0001), metrics=['accuracy'])
    #********* End *********#
    model.fit(train_images, onehot, epochs=20, batch_size=32, verbose=0)
    result = model.predict(test_images, batch_size=10)
    predict_idx = np.argmax(result, axis=1)
    return predict_idx