使用AlexNet训练自己的数据集

前言：

前两篇分别介绍两个图像识别的模型，第一个是mnist手写体图像识别，第二个是在第一个代码的基础上增加了一些优化技巧，例如正则化、dropout等，并且比较加上各种优化技巧之后图像识别的结果。 接下来介绍几个图像识别中比较经典的算法。具体的就介绍AlexNet 、VGG19 、 ResNet_152  、 InceptionV4 、DenseNet这五个模型，并且测试一下这些模型在卫星图像分类上的效果。

 

数据集介绍：

本次数据集是百度点石城市功能分类初赛的数据集，数据集的具体介绍见链接，在本代码中我们仅仅只使用数据集的图像，对于数据集中文本的使用等在一个专栏在讲解。

 

模型一: AlexNet

 

模型的介绍：

Alexnet是人工智能三大教父之一Hinton的学生Alex Krizhevsky发明的一个Deep Learning模型，一举摘下了视觉领域竞赛ILSVRC 2012的桂冠，在百万量级的ImageNet数据集合上，效果大幅度超过传统的方法，从传统的70%多提升到80%多。Alexnet成功的原因有五个：

原因一：  数据增强  常用的方法有  水平翻转 随机裁剪、平移变换 颜色、光照变换

原因二：   使用Dropout防止过拟合

原因三：   使用ReLU激活函数代替传统的Tanh或者Logistic

原因四：  Local Response Normalization 实际就是利用临近的数据做归一化。

原因五：  Overlapping的意思是有重叠，即Pooling的步长比Pooling Kernel的对应边要小。

 

模型的架构图：

这个图虽然比较直观的展示了Alexnet的架构，五层卷积层加上三层全连接层，但是在我们写代码的我们要知道每层卷积的步长，卷积核大小一类的信息，怎么办，okay下面一幅图就比较适合解释这个问题。okay这样的话，我们就能知道每一层卷积包含那些操作了。在我们Alexnet每一层的架构有了一定了解之后，我们开始我们的代码，从代码中分析具体过程。

 

# 为了能够更好的理解Alexnet网络， 我写了两个python文件，一个是主函数文件AlexNet_Train.py，这里面我们主要看怎么加载数据，调用Alexnet网络，以及优化器的设置。而Alexnet.py中存放的是Alexnet的网络架构。

 

首先是主程序AlexNet_Train.py：

主函数文件比较简单，可以分成以下几个步骤，定义一些占位符(挖坑)，调用Alexnet网络，并且返回一个大小为[batch_size, label]的隐层特征，再然后使用选择softmax以及adam优化器计算隐层特征和真实label的差距，并更新数据。最后即是feed数据(填坑)。 之所以写的很简单是，没有加上一些模型保存和加载，因为比较麻烦。

# -*- coding: utf-8 -*-
# @Time    : 2019/7/2 14:37
# @Author  : YYLin
# @Email   : [email protected]
# @File    : AlexNet_Train.py
from Alexnet import alexNet
import tensorflow as tf
import os
import cv2
import numpy as np
from keras.utils import to_categorical

# 定义一下训练中所需要的一些变量
# 站在现在的角度来看AlexNet模型的话 比较简单 所以可以用较大的batch_size
batch_size = 128
img_high = 100
img_width = 100
Channel = 3
label = 9

# 定义输入图像的占位符
inputs = tf.placeholder(tf.float32, [batch_size, img_high, img_width, Channel], name='inputs')
y = tf.placeholder(dtype=tf.float32, shape=[batch_size, label], name='label')
keep_prob = tf.placeholder("float")

# 调用alexNet训练数据  model.fc3 最后分类的结果为[batch_size, label]
model = alexNet(inputs, keep_prob, label)
score = model.fc3
softmax_result = tf.nn.softmax(score)

# 定义损失函数 以及相对应的优化器
cross_entropy = -tf.reduce_sum(y*tf.log(softmax_result))
Optimizer = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

# 用于判断验证集的结果是否正确
correct_prediction = tf.equal(tf.argmax(softmax_result, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))


# 定义一个读取训练集和验证集的函数
def load_satetile_image(batch_size=128, dataset='train'):
    img_list = []
    label_list = []
    dir_counter = 0

    if dataset == 'train':
        path = '../Dataset/baidu/train_image/train'

        # 对路径下的所有子文件夹中的所有jpg文件进行读取并存入到一个list中
        for child_dir in os.listdir(path):
            child_path = os.path.join(path, child_dir)
            for dir_image in os.listdir(child_path):
                img = cv2.imread(os.path.join(child_path, dir_image))
                img_list.append(img)
                label_list.append(dir_counter)

            dir_counter += 1
    else:
        path = '../Dataset/baidu/valid_image/valid'

        # 对路径下的所有子文件夹中的所有jpg文件进行读取并存入到一个list中
        for child_dir in os.listdir(path):
            child_path = os.path.join(path, child_dir)
            for dir_image in os.listdir(child_path):
                img = cv2.imread(os.path.join(child_path, dir_image))
                img_list.append(img)
                label_list.append(dir_counter)

            dir_counter += 1

    # 返回的img_list转成了 np.array的格式
    X_train = np.array(img_list)
    Y_train = to_categorical(label_list, 9)
    # print('to_categorical之后Y_train的类型和形状:', type(Y_train), Y_train.shape)

    # 加载数据的时候 重新排序
    # print('X_train.shape, Y_train.shape:', X_train.shape, Y_train.shape)
    data_index = np.arange(X_train.shape[0])
    np.random.shuffle(data_index)
    data_index = data_index[:batch_size]
    x_batch = X_train[data_index, :, :, :]
    y_batch = Y_train[data_index, :]

    return x_batch, y_batch


# 开始feed 数据并且训练数据
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for i in range(500000//batch_size):
        # 加载训练集和验证集
        img, img_label = load_satetile_image(batch_size, dataset='train')
        img_valid, img_valid_label = load_satetile_image(batch_size, dataset='vaild')
        # print('使用 mnist.train.next_batch加载的数据集形状', img.shape, type(img))

        # print('模型使用的是dropout的模型')
        dropout_rate = 0.5
        Optimizer.run(feed_dict={inputs: img, y: img_label, keep_prob: dropout_rate})

        # print('经过 tf.reshape之后数据的形状以及类型是:', img.shape, type(img))
        if i % 20 == 0:
            train_accuracy = accuracy.eval(feed_dict={inputs: img, y: img_label, keep_prob: dropout_rate})
            print("step %d, training accuracy %g" % (i, train_accuracy))

        # 输出验证集上的结果
        if i % 50 == 0:
            dropout_rate = 1
            valid_socre = accuracy.eval(feed_dict={inputs: img_valid, y: img_valid_label, keep_prob: dropout_rate})
            print("step %d, valid accuracy %g" % (i, valid_socre))

 

然后是本程序核心，AlexNet模型：

在这里讲一下我复现这些经典模型的方法，因为我不是专门研究图像是别的，所以我不是直接上GitHub上找别人的源码复现一下看看效果，而是首先上知乎上了解以下这些模型的基本架构，等我明白了具体架构的时候，我才会去上GitHub上找和我模型相关的源码。因为你不能保证别人开源的代码的架构是不是正确的，当你理解了架构之后，在看别人模型的时候你就有了一个粗浅的判断。okay！！！！！！！！话不多说看一下大佬们的代码结构

 

由AlexNet的架构图我们可以知道，AlexNet总共有5层卷积层，

第一层： 卷积核大小是11*11  步长是4*4  通道数为96  紧接着是一个relu激活函数 局部正则化 最后是一个卷积核大小为3*3 步长为2*2 的最大池化层。  代码中conv1 在卷积最后没有使用relu激活函数   其他均满足要求

第二层： 卷积核大小是5*5 步长是1*1 通道数为256 紧接着是一个relu激活函数 局部正则化 最后是一个卷积核大小为3*3 步长为2*2 的最大池化层。  代码中conv2除了没使用relu激活函数 其他均满足

第三层、第四层、第五层：   卷积核大小为 3 * 3，  步长为 1*1，通道数分别是384 384 256，同样没有增加relu激活函数。

最后全连接层是我自己根据实际需求修改的。因为我加载图像的大小是100*100，这个是不会对程序有影响的。而且上面说的没有增加relu是我专门拿出来的，意思是不要相信任何人的公开的源码，毕竟不收费你也不确定人家对不对。所以一定要好好看论文，简单理解模型之后再复现代码。

 

# -*- coding: utf-8 -*-
# @Time    : 2019/7/1 20:40
# @Author  : YYLin
# @Email   : [email protected]
# @File    : Alexnet.py
import tensorflow as tf


# 定义一个最大池化层
def maxPoolLayer(x, kHeight, kWidth, strideX, strideY, name, padding="SAME"):
    return tf.nn.max_pool(x, ksize=[1, kHeight, kWidth, 1],
                          strides=[1, strideX, strideY, 1], padding=padding, name=name)


# 使用dropout 随机丢包
def dropout(x, keepPro, name=None):
    return tf.nn.dropout(x, keepPro, name)


# 定义一个局部正则化
def LRN(x, r, alpha, beta, name=None, bias=1.0):
    return tf.nn.local_response_normalization(x, depth_radius=r, alpha=alpha, beta=beta, bias=bias, name=name)


# 定义一个全连接层的函数 其实可以修改成之前我写的那个
def fcLayer(x, inputD, outputD, reluFlag, name):
    with tf.variable_scope(name) as scope:
        w = tf.get_variable("w", shape=[inputD, outputD], dtype="float")
        b = tf.get_variable("b", [outputD], dtype="float")
        out = tf.nn.xw_plus_b(x, w, b, name=scope.name)
        if reluFlag:
            return tf.nn.relu(out)
        else:
            return out


def convLayer(x, kHeight, kWidth, strideX, strideY, featureNum, name, padding="SAME", groups=1):
              
    channel = int(x.get_shape()[-1])
    conv = lambda a, b: tf.nn.conv2d(a, b, strides=[1, strideY, strideX, 1], padding=padding)
    with tf.variable_scope(name) as scope:
        w = tf.get_variable("w", shape=[kHeight, kWidth, channel/groups, featureNum])
        b = tf.get_variable("b", shape=[featureNum])

        xNew = tf.split(value=x, num_or_size_splits=groups, axis=3)
        wNew = tf.split(value=w, num_or_size_splits=groups, axis=3)

        featureMap = [conv(t1, t2) for t1, t2 in zip(xNew, wNew)]
        mergeFeatureMap = tf.concat(axis=3, values=featureMap)
        # print mergeFeatureMap.shape
        out = tf.nn.bias_add(mergeFeatureMap, b)
        return tf.nn.relu(tf.reshape(out, mergeFeatureMap.get_shape().as_list()), name = scope.name)


# 定义一个alexNet类别 方便之后调用
class alexNet(object):
    def __init__(self, x, keepPro, classNum):
        self.X = x
        self.KEEPPRO = keepPro
        self.CLASSNUM = classNum
        # 用于加载alexNet 所需要的各种操作
        self.begin_alexNet()

    def begin_alexNet(self):
        conv1 = convLayer(self.X, 11, 11, 4, 4, 96, "conv1", "VALID")
        lrn1 = LRN(conv1, 2, 2e-05, 0.75, "norm1")
        pool1 = maxPoolLayer(lrn1, 3, 3, 2, 2, "pool1", "VALID")

        conv2 = convLayer(pool1, 5, 5, 1, 1, 256, "conv2", groups = 2)
        lrn2 = LRN(conv2, 2, 2e-05, 0.75, "lrn2")
        pool2 = maxPoolLayer(lrn2, 3, 3, 2, 2, "pool2", "VALID")

        conv3 = convLayer(pool2, 3, 3, 1, 1, 384, "conv3")

        conv4 = convLayer(conv3, 3, 3, 1, 1, 384, "conv4", groups = 2)

        conv5 = convLayer(conv4, 3, 3, 1, 1, 256, "conv5", groups = 2)
        pool5 = maxPoolLayer(conv5, 3, 3, 2, 2, "pool5", "VALID")
        print('alexNet中最后一层卷积层的形状是:', pool5.shape)

        fcIn = tf.reshape(pool5, [-1, 256 * 2 * 2])
        fc1 = fcLayer(fcIn, 256 * 2 * 2, 4096, True, "fc6")
        dropout1 = dropout(fc1, self.KEEPPRO)

        fc2 = fcLayer(dropout1, 4096, 4096, True, "fc7")
        dropout2 = dropout(fc2, self.KEEPPRO)

        self.fc3 = fcLayer(dropout2, 4096, self.CLASSNUM, True, "fc8")

okay 最后看一下AlexNet在卫星图像分类上的效果吧！！！！！！！！！！！！！！ 

训练时间比较短，不能说明问题，先让程序跑着，跑个差不多的时候在分析一下效果好或者不好的原因。