【TensorFlow2 之015】在 TF 2.0 中实现 AlexNet

一、说明

在这篇文章中，我们将展示如何在 TensorFlow 2.0 中实现基本的卷积神经网络 \(AlexNet\)。AlexNet 架构由 Alex Krizhevsky 设计，并与 Ilya Sutskever 和 Geoffrey Hinton 一起发布。并获得Image Net2012竞赛中冠军。

教程概述：

理论回顾
在 TensorFlow 2.0 中的实现

二理论回顾

现实生活中的计算机视觉问题需要大量高质量数据进行训练。过去，人们使用 CIFAR 和 NORB 数据集作为计算机视觉问题的基准数据集。然而，ImageNet竞赛改变了这一点。该数据集需要比以前更复杂的网络才能获得良好的结果。

AlexNet 是 2012 年取得最佳结果的一种网络架构。它的 Top-5 错误率为 15.3%。第二好的成绩远远落后（26.2%）。

该架构有大约 6000 万个参数，由以下层组成。

图层类型	特征图	尺寸	内核大小	跨步	激活
图像	1	227×227	–	–	–
卷积	96	55×55	11×11	4	ReLU
最大池化	96	27×27	3×3	2	–
卷积	256	27×27	5×5	1	ReLU
最大池化	256	13×13	3×3	2	–
卷积	第384章	13×13	3×3	1	ReLU
卷积	第384章	13×13	3×3	1	ReLU
卷积	256	13×13	3×3	1	ReLU
最大池化	256	6×6	3×3	2	–
完全连接	–	4096	–	–	ReLU
完全连接	–	4096	–	–	ReLU
完全连接	–	1000	–	–	软最大

在我们的例子中，我们将仅在 ImageNet 数据集中的两个类上训练模型，因此我们的最后一个全连接层将只有两个具有 Softmax 激活函数的神经元。

有一些变化使得 AlexNet 与当时的其他网络不同。让我们看看是什么改变了历史！

2.1 重叠的池化层

标准池化层汇总同一内核图中相邻神经元组的输出。传统上，相邻池单元总结的邻域不重叠。重叠池化层与标准池化层类似，只是计算 Max 的相邻窗口彼此重叠。

重叠池化与非重叠池化

2.2 ReLU 非线性

评估神经元输出的传统方法是使用 sigmoid 或 tanh 激活函数。这两个函数固定在最小值和最大值之间，因此它们是饱和非线性的。然而，在 AlexNet 中，使用了修正线性单位函数，或者简称为 \(ReLU\)。该函数的阈值为\(0\)。这是一个非饱和激活函数。

\(ReLU\) 函数需要更少的计算并允许更快的学习，这对在大型数据集上训练的大型模型的性能有很大影响。

2.3 局部响应标准化

局部响应归一化 (LRN) 首次在 AlexNet 架构中引入，其中选择的激活函数是 \(ReLU\)。使用 LRN 的原因是为了鼓励 侧向抑制。这是指神经元减少其邻居活动的能力。当我们使用 ReLU 激活函数处理神经元时，这非常有用。具有 \(ReLU\) 激活函数的神经元具有无界激活，我们需要 LRN 对其进行标准化。

三. TensorFlow 2.0中的实现

交互式 Colab 笔记本可在以下链接找到

让我们从导入所有必需的库开始

# Load the TensorBoard notebook extension
%load_ext tensorboard

import datetime
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

from tensorflow.keras import Model
from tensorflow.keras.models import Sequential
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.losses import categorical_crossentropy
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D, Dropout

导入后，我们需要准备数据。在这里，我们将仅使用 ImageNet 数据集的一小部分。使用以下代码，您可以下载所有图像并将它们存储在文件夹中。

import cv2
import urllib
import requests
import PIL.Image
import numpy as np
from bs4 import BeautifulSoup

#ship synset
page = requests.get("http://www.image-net.org/api/text/imagenet.synset.geturls?wnid=n04194289")
soup = BeautifulSoup(page.content, 'html.parser')
#bicycle synset
bikes_page = requests.get("http://www.image-net.org/api/text/imagenet.synset.geturls?wnid=n02834778")
bikes_soup = BeautifulSoup(bikes_page.content, 'html.parser')

str_soup=str(soup)
split_urls=str_soup.split('\r\n')

bikes_str_soup=str(bikes_soup)
bikes_split_urls=bikes_str_soup.split('\r\n')

!mkdir /content/train
!mkdir /content/train/ships
!mkdir /content/train/bikes
!mkdir /content/validation
!mkdir /content/validation/ships
!mkdir /content/validation/bikes

img_rows, img_cols = 32, 32
input_shape = (img_rows, img_cols, 3)

def url_to_image(url):
    resp = urllib.request.urlopen(url)
    image = np.asarray(bytearray(resp.read()), dtype="uint8")
    image = cv2.imdecode(image, cv2.IMREAD_COLOR)
    return image

n_of_training_images=100
for progress in range(n_of_training_images):
    if not split_urls[progress] == None:
        try:
            I = url_to_image(split_urls[progress])
            if (len(I.shape))==3:
                save_path = '/content/train/ships/img'+str(progress)+'.jpg'
                cv2.imwrite(save_path,I)
        except:
            None

for progress in range(n_of_training_images):
    if not bikes_split_urls[progress] == None:
        try:
            I = url_to_image(bikes_split_urls[progress])
            if (len(I.shape))==3:
                save_path = '/content/train/bikes/img'+str(progress)+'.jpg'
                cv2.imwrite(save_path,I)
        except:
            None


for progress in range(50):
    if not split_urls[progress] == None:
        try:
            I = url_to_image(split_urls[n_of_training_images+progress])
            if (len(I.shape))==3:
                save_path = '/content/validation/ships/img'+str(progress)+'.jpg'
                cv2.imwrite(save_path,I)
        except:
            None


for progress in range(50):
    if not bikes_split_urls[progress] == None:
        try:
            I = url_to_image(bikes_split_urls[n_of_training_images+progress])
            if (len(I.shape))==3:
                save_path = '/content/validation/bikes/img'+str(progress)+'.jpg'
                cv2.imwrite(save_path,I)
        except:
            None

现在我们可以创建一个网络。原始 AlexNet 的最后一层有 1000 个神经元，但这里我们只使用一个。这是因为我们只将图像用于两个类。为了构建我们的卷积神经网络，我们将使用 Sequential API。

num_classes = 2

# AlexNet model
class AlexNet(Sequential):
    def __init__(self, input_shape, num_classes):
        super().__init__()

        self.add(Conv2D(96, kernel_size=(11,11), strides= 4,
                        padding= 'valid', activation= 'relu',
                        input_shape= input_shape,
                        kernel_initializer= 'he_normal'))
        self.add(MaxPooling2D(pool_size=(3,3), strides= (2,2),
                              padding= 'valid', data_format= None))

        self.add(Conv2D(256, kernel_size=(5,5), strides= 1,
                        padding= 'same', activation= 'relu',
                        kernel_initializer= 'he_normal'))
        self.add(MaxPooling2D(pool_size=(3,3), strides= (2,2),
                              padding= 'valid', data_format= None)) 

        self.add(Conv2D(384, kernel_size=(3,3), strides= 1,
                        padding= 'same', activation= 'relu',
                        kernel_initializer= 'he_normal'))

        self.add(Conv2D(384, kernel_size=(3,3), strides= 1,
                        padding= 'same', activation= 'relu',
                        kernel_initializer= 'he_normal'))

        self.add(Conv2D(256, kernel_size=(3,3), strides= 1,
                        padding= 'same', activation= 'relu',
                        kernel_initializer= 'he_normal'))

        self.add(MaxPooling2D(pool_size=(3,3), strides= (2,2),
                              padding= 'valid', data_format= None))

        self.add(Flatten())
        self.add(Dense(4096, activation= 'relu'))
        self.add(Dense(4096, activation= 'relu'))
        self.add(Dense(1000, activation= 'relu'))
        self.add(Dense(num_classes, activation= 'softmax'))

        self.compile(optimizer= tf.keras.optimizers.Adam(0.001),
                    loss='categorical_crossentropy',
                    metrics=['accuracy'])

model = AlexNet((227, 227, 3), num_classes)

创建模型后，我们定义一些重要的参数以供以后使用。此外，让我们创建图像数据生成器。\(AlexNet\)的参数非常多，有6000万个，这是一个巨大的数字。如果没有足够的数据，这将很可能导致过度拟合。因此，在这里，我们将利用数据增强技术，您可以在此处找到更多相关信息。

出于同样的原因，AlexNet 中使用了 dropout 层。该技术包括以预定概率“关闭”神经元。这迫使每个神经元具有更强大的特征，可以与其他神经元一起使用。我们不会在这里使用 dropout 层，因为我们不会使用整个数据集。

# some training parameters
EPOCHS = 100
BATCH_SIZE = 32
image_height = 227
image_width = 227
train_dir = "train"
valid_dir = "validation"
model_dir = "my_model.h5"

train_datagen = ImageDataGenerator(
                  rescale=1./255,
                  rotation_range=10,
                  width_shift_range=0.1,
                  height_shift_range=0.1,
                  shear_range=0.1,
                  zoom_range=0.1)

train_generator = train_datagen.flow_from_directory(train_dir,
                                                    target_size=(image_height, image_width),
                                                    color_mode="rgb",
                                                    batch_size=BATCH_SIZE,
                                                    seed=1,
                                                    shuffle=True,
                                                    class_mode="categorical")

valid_datagen = ImageDataGenerator(rescale=1.0/255.0)
valid_generator = valid_datagen.flow_from_directory(valid_dir,
                                                    target_size=(image_height, image_width),
                                                    color_mode="rgb",
                                                    batch_size=BATCH_SIZE,
                                                    seed=7,
                                                    shuffle=True,
                                                    class_mode="categorical"
                                                    )
train_num = train_generator.samples
valid_num = valid_generator.samples

现在我们可以设置TensorBoard并开始训练我们的模型。这样我们就可以实时跟踪模型性能。

log_dir="logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir)
callback_list = [tensorboard_callback]

# start training
model.fit(train_generator,
                    epochs=EPOCHS,
                    steps_per_epoch=train_num // BATCH_SIZE,
                    validation_data=valid_generator,
                    validation_steps=valid_num // BATCH_SIZE,
                    callbacks=callback_list,
                    verbose=0)

# save the whole model
model.save(model_dir)

%tensorboard --logdir logs/fit

让我们使用我们的模型进行一些预测并将其可视化。

class_names = ['bike', 'ship']

x_valid, label_batch  = next(iter(valid_generator))

prediction_values = model.predict_classes(x_valid)

# set up the figure
fig = plt.figure(figsize=(10, 6))
fig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)

# plot the images: each image is 227x227 pixels
for i in range(8):
    ax = fig.add_subplot(2, 4, i + 1, xticks=[], yticks=[])
    ax.imshow(x_valid[i,:],cmap=plt.cm.gray_r, interpolation='nearest')
  
    if prediction_values[i] == np.argmax(label_batch[i]):
        # label the image with the blue text
        ax.text(3, 17, class_names[prediction_values[i]], color='blue', fontsize=14)
    else:
        # label the image with the red text
        ax.text(3, 17, class_names[prediction_values[i]], color='red', fontsize=14)