AlexNet-基于keras训练猫狗分类

以你之姓@ 2021-11-17 22:46 492阅读 0赞

# 什么是AlexNet模型 #

![在这里插入图片描述][20210326193455111.png]  
![在这里插入图片描述][20210326193502158.png]

![在这里插入图片描述][20190731103109261.png]  
统共分为8层，前五层为卷积层，后三层为全连接层。

这是一个AlexNet的网格结构图，其实并不复杂，很好的反应了AlexNet的结构：

--------------------

1、一张原始图片被resize到(224,224,3)；  
2、使用步长为4x4，大小为11的卷积核对图像进行卷积，输出的特征层为96层，输出的shape为(55,55,96)；  
3、使用步长为2的最大池化层进行池化，此时输出的shape为(27,27,96)  
4、使用步长为1x1，大小为5的卷积核对图像进行卷积，输出的特征层为256层，输出的shape为(27,27,256)；  
5、使用步长为2的最大池化层进行池化，此时输出的shape为(13,13,256)；  
6、使用步长为1x1，大小为3的卷积核对图像进行卷积，输出的特征层为384层，输出的shape为(13,13,384)；  
7、使用步长为1x1，大小为3的卷积核对图像进行卷积，输出的特征层为384层，输出的shape为(13,13,384)；  
8、使用步长为1x1，大小为3的卷积核对图像进行卷积，输出的特征层为256层，输出的shape为(13,13,256)；  
9、使用步长为2的最大池化层进行池化，此时输出的shape为(6,6,256)；  
10、两个全连接层，最后输出为1000类

--------------------

最后输出的就是每个类的预测。  
从上面的图也可以看出，其实最大的内存与计算消耗在与第一个全连接层的实现，它的参数有37M之多。

# 训练前准备 #

## 数据集处理 ##

#### 在模型训练之前，需要将数据集的内容保存到一个TXT文件中，便于读取。 ####

txt文件的保存格式如下：

文件名;种类

![在这里插入图片描述][2021032619471378.png]  
具体操作步骤如下：  
1、将训练文件存到"./data/image/train/"目录下。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25nbG9uZ3NoZW4_size_16_color_FFFFFF_t_70]  
2、调用如下代码：

import os
    
    photos = os.listdir("./data/image/train/")
    
    # 该部分用于将
    with open("data/dataset.txt","w") as f:
        for photo in photos:
            name = photo.split(".")[0]
            if name=="cat":
                f.write(photo + ";0\n")
            elif name=="dog":
                f.write(photo + ";1\n")
    f.close()

就可以得到训练数据集的文本文件。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25nbG9uZ3NoZW4_size_16_color_FFFFFF_t_70 1]

## 2.创建keras的AlexNet模型 ##

该步就是按照alexnet的结构创建Alexnet的模型

from keras.models import Sequential
    from keras.layers import Dense,Activation,Conv2D,MaxPooling2D,Flatten,Dropout,BatchNormalization
    from keras.datasets import mnist
    from keras.utils import np_utils
    from keras.optimizers import Adam
    
    def AlexNet(input_shape=(224,224,3),output_shape=2):
        # AlexNet
        model = Sequential()
        # 使用步长为4x4，大小为11的卷积核对图像进行卷积，输出的特征层为96层，输出的shape为(55,55,96)；
        # 所建模型后输出为48特征层
        model.add(
            Conv2D(
                filters=48, 
                kernel_size=(11,11),
                strides=(4,4),
                padding='valid',
                input_shape=input_shape,
                activation='relu'
            )
        )
        
        model.add(BatchNormalization())
        # 使用步长为2的最大池化层进行池化，此时输出的shape为(27,27,96)
        model.add(
            MaxPooling2D(
                pool_size=(3,3), 
                strides=(2,2), 
                padding='valid'
            )
        )
        # 使用步长为1x1，大小为5的卷积核对图像进行卷积，输出的特征层为256层，输出的shape为(27,27,256)；
        # 所建模型后输出为128特征层
        model.add(
            Conv2D(
                filters=128, 
                kernel_size=(5,5), 
                strides=(1,1), 
                padding='same',
                activation='relu'
            )
        )
        
        model.add(BatchNormalization())
        # 使用步长为2的最大池化层进行池化，此时输出的shape为(13,13,256)；
        model.add(
            MaxPooling2D(
                pool_size=(3,3),
                strides=(2,2),
                padding='valid'
            )
        )
        # 使用步长为1x1，大小为3的卷积核对图像进行卷积，输出的特征层为384层，输出的shape为(13,13,384)；
        # 所建模型后输出为192特征层
        model.add(
            Conv2D(
                filters=192, 
                kernel_size=(3,3),
                strides=(1,1), 
                padding='same', 
                activation='relu'
            )
        ) 
        # 使用步长为1x1，大小为3的卷积核对图像进行卷积，输出的特征层为384层，输出的shape为(13,13,384)；
        # 所建模型后输出为192特征层
        model.add(
            Conv2D(
                filters=192, 
                kernel_size=(3,3), 
                strides=(1,1), 
                padding='same', 
                activation='relu'
            )
        )
        # 使用步长为1x1，大小为3的卷积核对图像进行卷积，输出的特征层为256层，输出的shape为(13,13,256)；
        # 所建模型后输出为128特征层
        model.add(
            Conv2D(
                filters=128, 
                kernel_size=(3,3), 
                strides=(1,1), 
                padding='same', 
                activation='relu'
            )
        )
        # 使用步长为2的最大池化层进行池化，此时输出的shape为(6,6,256)；
        model.add(
            MaxPooling2D(
                pool_size=(3,3), 
                strides=(2,2), 
                padding='valid'
            )
        )
        # 两个全连接层，最后输出为1000类,这里改为2类
        # 缩减为1024
        model.add(Flatten())
        model.add(Dense(1024, activation='relu'))
        model.add(Dropout(0.25))
        
        model.add(Dense(1024, activation='relu'))
        model.add(Dropout(0.25))
        
        model.add(Dense(output_shape, activation='softmax'))
    
        return model

# 开始训练 #

## 1、训练的主函数 ##

训练的主函数主要包括如下部分：  
1、读取训练用txt，并打乱，利用该txt进行训练集和测试集的划分。  
2、建立AlexNet模型  
3、设定模型保存的方式、学习率下降的方式、是否需要早停。  
4、利用model.fit\_generator训练模型。  
具体代码如下：

if __name__ == "__main__":
        # 模型保存的位置
        log_dir = "./logs/"
    
        # 打开数据集的txt
        with open(r".\data\dataset.txt","r") as f:
            lines = f.readlines()
    
        # 打乱行，这个txt主要用于帮助读取数据来训练
        # 打乱的数据更有利于训练
        np.random.seed(10101)
        np.random.shuffle(lines)
        np.random.seed(None)
    
        # 90%用于训练，10%用于估计。
        num_val = int(len(lines)*0.1)
        num_train = len(lines) - num_val
    
        # 建立AlexNet模型
        model = AlexNet()
        
        # 保存的方式，3世代保存一次
        checkpoint_period1 = ModelCheckpoint(
                                        log_dir + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5',
                                        monitor='acc', 
                                        save_weights_only=False, 
                                        save_best_only=True, 
                                        period=3
                                    )
        # 学习率下降的方式，acc三次不下降就下降学习率继续训练
        reduce_lr = ReduceLROnPlateau(
                                monitor='acc', 
                                factor=0.5, 
                                patience=3, 
                                verbose=1
                            )
        # 是否需要早停，当val_loss一直不下降的时候意味着模型基本训练完毕，可以停止
        early_stopping = EarlyStopping(
                                monitor='val_loss', 
                                min_delta=0, 
                                patience=10, 
                                verbose=1
                            )
    
        # 交叉熵
        model.compile(loss = 'categorical_crossentropy',
                optimizer = Adam(lr=1e-3),
                metrics = ['accuracy'])
    
        # 一次的训练集大小
        batch_size = 64
    
        print('Train on {} samples, val on {} samples, with batch size {}.'.format(num_train, num_val, batch_size))
        
        # 开始训练
        model.fit_generator(generate_arrays_from_file(lines[:num_train], batch_size),
                steps_per_epoch=max(1, num_train//batch_size),
                validation_data=generate_arrays_from_file(lines[num_train:], batch_size),
                validation_steps=max(1, num_val//batch_size),
                epochs=150,
                initial_epoch=0,
                callbacks=[checkpoint_period1, reduce_lr])
        model.save_weights(log_dir+'last1.h5')

model.fit\_generator需要用到python的生成器来滚动读取数据，具体方法看第二步。

## 2、keras数据生成器 ##

Keras的数据生成器就是在一个while 1的无限循环中不断生成batch大小的数据集。

def generate_arrays_from_file(lines,batch_size):
        # 获取总长度
        n = len(lines)
        i = 0
        while 1:
            X_train = []
            Y_train = []
            # 获取一个batch_size大小的数据
            for b in range(batch_size):
                if i==0:
                    np.random.shuffle(lines)
                name = lines[i].split(';')[0]
                # 从文件中读取图像
                img = cv2.imread(r".\data\image\train" + '/' + name)
                img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
                img = img/255
                X_train.append(img)
                Y_train.append(lines[i].split(';')[1])
                # 读完一个周期后重新开始
                i = (i+1) % n
            # 处理图像
            X_train = utils.resize_image(X_train,(224,224))
            X_train = X_train.reshape(-1,224,224,3)
            Y_train = np_utils.to_categorical(np.array(Y_train),num_classes= 2)   
            yield (X_train, Y_train)

在其中用到了一些处理函数，我存在了utils.py工具人文件中。

import matplotlib.image as mpimg
    import numpy as np
    import cv2
    import tensorflow as tf
    from tensorflow.python.ops import array_ops
    
    def load_image(path):
        # 读取图片，rgb
        img = mpimg.imread(path)
        # 将图片修剪成中心的正方形
        short_edge = min(img.shape[:2])
        yy = int((img.shape[0] - short_edge) / 2)
        xx = int((img.shape[1] - short_edge) / 2)
        crop_img = img[yy: yy + short_edge, xx: xx + short_edge]
        return crop_img
    
    def resize_image(image, size):
        with tf.name_scope('resize_image'):
            images = []
            for i in image:
                i = cv2.resize(i, size)
                images.append(i)
            images = np.array(images)
            return images
    
    def print_answer(argmax):
        with open("./data/model/index_word.txt","r",encoding='utf-8') as f:
            synset = [l.split(";")[1][:-1] for l in f.readlines()]
            
        print(synset[argmax])
        return synset[argmax]

## 3、主训练函数全部代码 ##

大家可以整体看看哈：

from keras.callbacks import TensorBoard, ModelCheckpoint, ReduceLROnPlateau, EarlyStopping
    from keras.utils import np_utils
    from keras.optimizers import Adam
    from model.AlexNet import AlexNet
    import numpy as np
    import utils
    import cv2
    from keras import backend as K
    K.set_image_dim_ordering('tf')
    
    def generate_arrays_from_file(lines,batch_size):
        # 获取总长度
        n = len(lines)
        i = 0
        while 1:
            X_train = []
            Y_train = []
            # 获取一个batch_size大小的数据
            for b in range(batch_size):
                if i==0:
                    np.random.shuffle(lines)
                name = lines[i].split(';')[0]
                # 从文件中读取图像
                img = cv2.imread(r".\data\image\train" + '/' + name)
                img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
                img = img/255
                X_train.append(img)
                Y_train.append(lines[i].split(';')[1])
                # 读完一个周期后重新开始
                i = (i+1) % n
            # 处理图像
            X_train = utils.resize_image(X_train,(224,224))
            X_train = X_train.reshape(-1,224,224,3)
            Y_train = np_utils.to_categorical(np.array(Y_train),num_classes= 2)   
            yield (X_train, Y_train)
    
    
    if __name__ == "__main__":
        # 模型保存的位置
        log_dir = "./logs/"
    
        # 打开数据集的txt
        with open(r".\data\dataset.txt","r") as f:
            lines = f.readlines()
    
        # 打乱行，这个txt主要用于帮助读取数据来训练
        # 打乱的数据更有利于训练
        np.random.seed(10101)
        np.random.shuffle(lines)
        np.random.seed(None)
    
        # 90%用于训练，10%用于估计。
        num_val = int(len(lines)*0.1)
        num_train = len(lines) - num_val
    
        # 建立AlexNet模型
        model = AlexNet()
        
        # 保存的方式，3世代保存一次
        checkpoint_period1 = ModelCheckpoint(
                                        log_dir + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5',
                                        monitor='acc', 
                                        save_weights_only=False, 
                                        save_best_only=True, 
                                        period=3
                                    )
        # 学习率下降的方式，acc三次不下降就下降学习率继续训练
        reduce_lr = ReduceLROnPlateau(
                                monitor='acc', 
                                factor=0.5, 
                                patience=3, 
                                verbose=1
                            )
        # 是否需要早停，当val_loss一直不下降的时候意味着模型基本训练完毕，可以停止
        early_stopping = EarlyStopping(
                                monitor='val_loss', 
                                min_delta=0, 
                                patience=10, 
                                verbose=1
                            )
    
        # 交叉熵
        model.compile(loss = 'categorical_crossentropy',
                optimizer = Adam(lr=1e-3),
                metrics = ['accuracy'])
    
        # 一次的训练集大小
        batch_size = 64
    
        print('Train on {} samples, val on {} samples, with batch size {}.'.format(num_train, num_val, batch_size))
        
        # 开始训练
        model.fit_generator(generate_arrays_from_file(lines[:num_train], batch_size),
                steps_per_epoch=max(1, num_train//batch_size),
                validation_data=generate_arrays_from_file(lines[num_train:], batch_size),
                validation_steps=max(1, num_val//batch_size),
                epochs=150,
                initial_epoch=0,
                callbacks=[checkpoint_period1, reduce_lr, early_stopping ])
        model.save_weights(log_dir+'last1.h5')

## 测试 ##

import numpy as np
    import utils
    import cv2
    from keras import backend as K
    from model.AlexNet import AlexNet
    
    K.set_image_dim_ordering('tf')
    
    if __name__ == "__main__":
        model = AlexNet()
        # 载入模型
        model.load_weights("./logs/ep039-loss0.004-val_loss0.652.h5")
        # 载入图片，并处理
        img = cv2.imread("./Test.jpg")
        img_RGB = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
        img_nor = img_RGB/255
        img_nor = np.expand_dims(img_nor,axis = 0)
        img_resize = utils.resize_image(img_nor,(224,224))
    	
    	# 预测~！
        #utils.print_answer(np.argmax(model.predict(img)))
        print(utils.print_answer(np.argmax(model.predict(img_resize))))
        cv2.imshow("ooo",img)
        cv2.waitKey(0)

# 参考链接 #

*  1.https://blog.csdn.net/weixin\_44791964/article/details/102748770

[20210326193455111.png]: /images/20211116/5966fe9b7abd42f18e02111df74f2013.png
[20210326193502158.png]: /images/20211116/28fce5f82a3b4912ac0b22435037787b.png
[20190731103109261.png]: /images/20211116/a8e6656aae294da5b32c59f49c380e1f.png
[2021032619471378.png]: /images/20211116/b18355a0d9ca4ca38c31e600fc869c78.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25nbG9uZ3NoZW4_size_16_color_FFFFFF_t_70]: /images/20211116/d77eebeaecdf4420bdd63b5e291f75db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25nbG9uZ3NoZW4_size_16_color_FFFFFF_t_70 1]: /images/20211116/279fec4e3087491aa60631a80536608d.png