PyTorch深度学习实战 | 猫狗分类

水深无声 2024-03-24 11:19 78阅读 0赞

![e5ae9169634c469788a666a1fbfa0091.jpeg][]

本文内容使用TensorFlow和Keras建立一个猫狗图片分类器。

![adb4d12f7b77447bac3239240dd15f21.jpeg][]

图1 猫狗图片

## 01、**安装TensorFlow和Keras库** ##

TensorFlow是一个采用数据流图（data flow graphs），用于数值计算的开源软件库。

节点（Nodes）在图中表示数学操作，图中的线（edges）则表示在节点间相互联系的多维数据数组，即张量（tensor）。它灵活的架构让你可以在多种平台上展开计算，例如台式计算机中的一个或多个CPU（或GPU），服务器，移动设备等等。

TensorFlow最初由Google大脑小组（隶属于Google机器智能研究机构）的研究员和工程师们开发出来，用于机器学习和深度神经网络方面的研究，但这个系统的通用性使其也可广泛用于其他计算领域。如图2所示。

![bf76f96d8cafc51862b4c3b364c27f39.gif][]

图2 TensorFlow数据流图

运行Anaconda Prompt工具，在该工具命令窗口下安装数值计算开源库(tensorflow)，如图3和图4所示，输入以下pip命令：

pip install tensorflow

![c4d354e7d5144afaa6ff43ba87f929fc.jpeg][]

图3 安装tensorflow库

![a0871502be1840e4b14fb0090a5a1cba.jpeg][]

图4 tensorflow库安装成功

Keras是一个由Python编写的开源人工神经网络库，可以作为Tensorflow、Microsoft-CNTK和Theano的高阶应用程序接口，进行深度学习模型的设计、调试、评估、应用和可视化，即高层神经网络API。

Keras的命名来自古希腊语“κέρας（牛角）”或“κραίνω（实现）”，意为将梦境化为现实的“牛角之门”。Keras的最初版本以Theano为后台，设计理念参考了Torch但完全由Python编写，自2017年起，Keras得到了Tensorflow团队的支持，其大部分组件被整合至Tensorflow的Python API中。在2018年Tensorflow 2.0.0公开后，Keras被正式确立为Tensorflow高阶API，即tf.keras。此外自2017年7月开始，Keras也得到了CNTK 2.0的后台支持。

Keras在代码结构上由面向对象方法编写，完全模块化并具有可扩展性，其运行机制和说明文档有将用户体验和使用难度纳入考虑，并试图简化复杂算法的实现难度。Keras支持现代人工智能领域的主流算法，包括前馈结构和递归结构的神经网络，也可以通过封装参与构建统计学习模型。在硬件和开发环境方面，Keras支持多操作系统下的多GPU并行计算，可以根据后台设置转化为Tensorflow、Microsoft-CNTK等系统下的组件。Keras为支持快速实验而生，能够把你的 idea 迅速转换为结果。

运行Anaconda Prompt工具，在该工具命令窗口下安装开源人工神经网络库(keras)，输入以下pip命令：

pip install keras

如图5、图6所示。

![6bfb2c1cef65417e90dc2dea07a9a364.jpeg][]

图5 安装keras库

![3731078baf8a4f35a5330f1ee8e3b855.jpeg][]

图6 keras库安装成功

环境配置好后，开始着手建立一个可以将猫狗图片分类的卷积神经网络，并使用到深度学习框架TensorFlow和Keras，配置网络以便远程访问Jupyter Notebook。

## 02、**案例实现** ##

**【目的】**

面向小数据集，使用keras进行数据增强；

使用keras构建两层卷积神经网络，实现猫狗分类；

对学习模型进行性能评估。

**【原理】**

基于keras框架，构建顺序神经网络，包含3层卷积，使用relu激活函数，同时使用max池化，后接2个全连接层，中间使用dropout进行降采样。

**【训练时长】**

50个epoch，每个epoch大概需要50秒，在it1080下训练过程共需要40分钟左右。

**【数据资源】**

cat\_dog数据集，从kaggle猫狗数据集中随机抽取3000个样本，其中训练集包含猫狗各1000，测试集包含猫狗各500。

**【步骤1】数据预处理**

使用小数据集（几百张到几千张图片）构造高效、实用的图像分类器的方法，需要通过一系列随机变换进行数据增强，可以抑制过拟合，使得模型的泛化能力更好。

在Keras中，这个步骤可以通过keras.preprocessing.image.ImageGenerator来实现：

（1) 在训练过程中，设置要施行的随机变换

（2) 通过.flow或.flow\_from\_directory(directory)方法实例化一个针对图像batch的生成器，这些生成器可以被用作keras模型相关方法的输入，如fit\_generator，evaluate\_generator和predict\_generator

导入相关资源的代码如下所示。

import numpy as np
    from keras.preprocessing.image import ImageDataGenerator #图像预处理
    import keras.backend as K
    K.set_image_dim_ordering('tf')
    from keras.models import Sequential
    from keras.layers import Convolution2D, MaxPooling2D
    from keras.layers import Activation, Dropout, Flatten, Dense
    加载数据的代码如下：
    使用.flow_from_directory()来从jpgs图片中直接产生数据和标签
    # 用于生成训练数据的对象
    train_gen= ImageDataGenerator(
            rescale=1./255,
            shear_range=0.2,
            zoom_range=0.2,
            horizontal_flip=True)
    
    # 用于生成测试数据的对象
    test_datagen = ImageDataGenerator(rescale=1./255)

参数解释如下：

*  rotation\_range是一个0~180的度数，用来指定随机选择图片的角度。

*  width\_shift和height\_shift用来指定水平和竖直方向随机移动的程度，这是两个0~1之间的比例。

*  rescale值将在执行其他处理前乘到整个图像上，图像在RGB通道都是0~255的整数，这样的操作可能使图像的值过高或过低，所以将这个值定为0~1之间的数。

*  shear\_range是用来进行剪切变换的程度。

*  zoom\_range用来进行随机的放大

*  horizontal\_flip随机地对图片进行水平翻转，这个参数适用于水平翻转不影响图片语义的时候

*  fill\_mode用来指定当需要进行像素填充，如旋转，水平和竖直位移时，如何填充新出现的像素

# 从指定路径小批量读取数据
    train_data = train_gen.flow_from_directory(
            '../datas/min_data/train', # t路径
            target_size=(150, 150), # 图片大小
            batch_size=32, # 每次读取的数量
            class_mode='binary') # 标签编码风格
    
    # 从测试集中分批读取验证数据
    val_data= test_gen.flow_from_directory(
            '../datas/min_data/test',
            target_size=(150, 150),
            batch_size=32,
            class_mode='binary')

**【步骤2】构建神经网络**

模型包含3层卷积加上ReLU激活函数，再接max-pooling层，代码如下所示

model = Sequential()
    model.add(Convolution2D(32, 3, 3, input_shape=(3, 150, 150)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    model.add(Convolution2D(32, 3, 3))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    model.add(Convolution2D(64, 3, 3))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))

两个全连接网络，并以单个神经元和sigmoid激活结束模型。这种选择会产生二分类的结果，与这种配置相适应使用binary\_crossentropy作为损失函数，每个卷积层的滤波器数目并不多。

为了防止过拟合，需要添加Dropout层，代码如下所示。

model.add(Flatten()) # 展平
    model.add(Dense(64)) # 全连接
    model.add(Activation('relu')) # 激活
    model.add(Dropout(0.5)) # 降采样
    model.add(Dense(1)) # 全连接
    model.add(Activation('sigmoid')) # 激活
    
    model.compile(loss='binary_crossentropy',
                  optimizer='rmsprop',
                  metrics=['accuracy'])

投入数据，训练网络，代码如下所示。

model.fit_generator(
            train_data, # 训练集
            samples_per_epoch=2000, # 训练样本数量
            nb_epoch=50, # 训练次数
            validation_data=val_data, #验证数据
            nb_val_samples=800 # 验证集大小
        )
    model.save_weights('../model/cat_dog.h5') # 保存模型文件

完整代码如下所示。

**【案例1】Conv\_3.ipynb**

from keras.preprocessing.image import ImageDataGenerator
    from keras.models import Sequential
    from keras.layers import Conv2D, MaxPooling2D
    from keras.layers import Activation, Dropout, Flatten, Dense
    from keras import backend as K
    
    
    # 图片大小
    img_width, img_height = 150, 150
    
    train_data_dir = '../datas/min_data/train'
    validation_data_dir = '../datas/min_data/test'
    nb_train_samples = 2000
    nb_val_samples =1000
    epochs = 50
    batch_size = 16
    
    if K.image_data_format() == 'channels_first':
        input_shape = (3, img_width, img_height)
    else:
        input_shape = (img_width, img_height, 3)
        
    # 数据读取、数据增强
    train_gen = ImageDataGenerator(
        rescale=1. / 255,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True)
    val_gen = ImageDataGenerator(rescale=1. / 255)
    
    train_data= train_gen.flow_from_directory(
        train_data_dir,
        target_size=(img_width, img_height),
        batch_size=batch_size,
        class_mode='binary')
    
    val_data=val_gen.flow_from_directory(
        validation_data_dir,
        target_size=(img_width, img_height),
        batch_size=batch_size,
        class_mode='binary')
    
    # 构建3层卷积神经网络
    model = Sequential()
    model.add(Conv2D(32, (3, 3), input_shape=input_shape))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    model.add(Conv2D(32, (3, 3)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    model.add(Conv2D(64, (3, 3)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    # 添加站平层、全连接层、降采样层
    model.add(Flatten())
    model.add(Dense(64))
    model.add(Activation('relu'))
    model.add(Dropout(0.5))
    model.add(Dense(1))
    model.add(Activation('sigmoid'))
    
    # 定义损失函数和优化策略
    model.compile(loss='binary_crossentropy',
                  optimizer='rmsprop',
                  metrics=['accuracy'])
    
    # 开始训练
    model.fit_generator(
        train_data,
        steps_per_epoch=nb_train_samples // batch_size,
        epochs=epochs,
        validation_data=val_data,
        validation_steps=nb_val_samples // batch_size)
    # 保存
    yaml_string = model.to_yaml()
    with open('cat_dog.yaml', 'w') as outfile:
        outfile.write(yaml_string)
    model.save_weights('cat_dog.h5')

运行结果如下：

Found 2000 images belonging to 2 classes.
    Found 1000 images belonging to 2 classes.
    WARNING:tensorflow:From /home/yangrh/anaconda3/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:1208: calling reduce_prod (from tensorflow.python.ops.math_ops) with keep_dims is deprecated and will be removed in a future version.
    Instructions for updating:
    keep_dims is deprecated, use keepdims instead
    WARNING:tensorflow:From /home/yangrh/anaconda3/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:1297: calling reduce_mean (from tensorflow.python.ops.math_ops) with keep_dims is deprecated and will be removed in a future version.
    Instructions for updating:
    keep_dims is deprecated, use keepdims instead
    Epoch 1/50
    125/125 [==============================] - 40s - loss: 0.7057 - acc: 0.5140 - val_loss: 0.6797 - val_acc: 0.5363
    Epoch 2/50
    125/125 [==============================] - 40s - loss: 0.6851 - acc: 0.5865 - val_loss: 0.6391 - val_acc: 0.6839
    ......
    Epoch 50/50
    125/125 [==============================] - 40s - loss: 0.3996 - acc: 0.8370 - val_loss: 0.5988 - val_acc: 0.7947

**【性能评估】**

50个epoch，每个epoch大概需要50秒，在it1080下训练过程共需要40分钟左右，在验证集上的准确率达到80%，训练准确率与错误率如图7所示。

![020f9bd931354cfaaf26a31dd9973348.png][]

图7 准确率与错误率

下面案例代码使用训练好的模型对猫狗图片进行分类。

**【案例2】Predict\_Model.ipynb**

import os
    import keras
    import keras.backend as K
    from tables.tests.test_tables import LargeRowSize
    K.set_image_dim_ordering('tf')
    import numpy as np
    from keras import callbacks
    from keras.models import Sequential, model_from_yaml, load_model
    from keras.layers import Dense, Conv2D, Flatten, Dropout, MaxPool2D
    from keras.optimizers import Adam, SGD
    from keras.preprocessing import image
    from keras.utils import np_utils, plot_model
    from sklearn.model_selection import train_test_split
    from keras.applications.resnet50 import preprocess_input, decode_predictions
    
    img_h, img_w = 150, 150
    image_size = (150, 150)
    nbatch_size = 256
    nepochs = 48
    nb_classes = 2
    
    def pred_data():
    
        with open('cat_dog.yaml') as yamlfile:
            loaded_model_yaml = yamlfile.read()
        model = model_from_yaml(loaded_model_yaml)
        model.load_weights('cat_dog.h5')
    
        sgd = Adam(lr=0.0003)
        model.compile(loss='categorical_crossentropy',optimizer=sgd, metrics=['accuracy'])
    
        images = []
        path='../datas/pred/'
        for f in os.listdir(path):
            img = image.load_img(path + f, target_size=image_size)
            img_array = image.img_to_array(img)
    
            x = np.expand_dims(img_array, axis=0)
            x = preprocess_input(x)
            result = model.predict_classes(x,verbose=0)
    
            print(f,result[0])
    
    # 0表示猫，1表示狗
    pred_data()

运行结果如下：

c7.jpg [0]
    dog.33.jpg [0]
    dog.34.jpg [1]
    dog.41.jpg [0]
    c3.jpg [0]
    c1.jpg [1]
    dog.36.jpg [0]
    c4.jpg [0]
    dog.35.jpg [0]
    dog.39.jpg [0]
    c5.jpg [0]
    dog.38.jpg [0]
    c2.jpg [0]
    dog.40.jpg [0]
    c6.jpg [1]
    c0.jpg [0]
    dog.37.jpg [0]

[e5ae9169634c469788a666a1fbfa0091.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/abc2320664444bb6b28f3701d4601672.png
[adb4d12f7b77447bac3239240dd15f21.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/acdbd0ece55e42afbd7b0d2d97341b1a.png
[bf76f96d8cafc51862b4c3b364c27f39.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/329455a8abb24985bc0fa9855af37a01.png
[c4d354e7d5144afaa6ff43ba87f929fc.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/df1e230c053f47a8b86f903f074efa46.png
[a0871502be1840e4b14fb0090a5a1cba.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/207387f67d9544498db47f832b03537d.png
[6bfb2c1cef65417e90dc2dea07a9a364.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/7bffea3a9e704b7fae2b2b3463886cc7.png
[3731078baf8a4f35a5330f1ee8e3b855.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/df14e9b204814e31b75d048211ea3591.png
[020f9bd931354cfaaf26a31dd9973348.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/71da9e7a929d435787e76223d47670d7.png