项目简介

心血来潮，想从零开始编写一个相对完整的深度学习小项目。想到就做，那么首先要考虑的问题是，写什么？

思量再三，我决定写一个宠物识别系统，即给定一张图片，判断图片上的宠物是什么。宠物种类暂定为四类——猫、狗、鼠、兔。之所以想到做这个，是因为在不使用公开数据集的情况下，宠物图片数据集获取的难度相对低一些。

小项目分为如下几个部分：

爬虫。从网络上下载宠物图片，构建训练用的数据集。模型构建、训练和调优。鉴于我们的数据比较少，这部分需要做迁移学习。模型部署和Web服务。将训练好的模型部署成web接口，并使用Vue.js + Element UI编写测试页面。好嘞，开搞吧！

本文涉及到的所有代码，均已上传到GitHub：

pets_classifer (https://github.com/AaronJny/pets_classifer)

转载请注明来源：https://blog.csdn.net/aaronjny/article/details/103605988

一、爬虫

训练模型肯定是需要数据集的，那么数据集从哪来？因为是从零开始嘛，假设我们做的这个问题，业内没有公开的数据集，我们需要自己制作数据集。

一个很简单的想法是，利用搜索引擎搜索相关图片，使用爬虫批量下载，然后人工去除不正确的图片。举个例子，我们先处理猫的图片，步骤如下：

1.使用搜索引擎搜索猫的图片。
2.使用爬虫将搜索出的猫的图片批量下载到本地，放到一个名为cats的文件夹里面。
3.人工浏览一遍图片，将“不包含猫”的图片和“除猫外还包含其他宠物（狗、鼠、兔）”的图片从文件夹中删除。

这样，猫的图片我们就搜集完成了，其他几个类别的图片也是类似的操作。不用担心人工过滤图片花费的时间较长，全部过一遍也就二十多分钟吧。

然后是搜索引擎的选择。搜索引擎用的比较多的无非两种——Google和百度。我分别使用Google和百度进行了图片搜索，发现百度的搜索结果远不如Google准确，于是就选择了Google，所以我的爬虫代码是基于Google编写的，运行我的爬虫代码需要你的网络能够访问Google。

如果你的网络不能访问Google，可以考虑自行实现基于百度的爬虫程序，逻辑都是相通的。

因为想让项目轻量级一些，故没有使用scrapy框架。爬虫使用requests+beautifulsoup4实现，并发使用gevent实现。

```python

- - coding: utf-8 - -

@File : spider.py

@Author : AaronJny

@Time : 2019/12/16

@Desc : 从谷歌下载指定图片

from gevent import monkey

monkey.patch_all() import functools import logging import os from bs4 import BeautifulSoup from gevent.pool import Pool import requests import settings

设置日志输出格式

logging.basicConfig(format='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s', level=logging.INFO)

搜索关键词字典

keywords_map = settings.IMAGE_CLASS_KEYWORD_MAP

图片保存根目录

images_root = settings.IMAGES_ROOT

每个类别下载多少页图片

download_pages = settings.SPIDER_DOWNLOAD_PAGES

图片编号字典，每种图片都从0开始编号，然后递增

images_index_map = dict(zip(keywords_map.keys(), [0 for _ in keywords_map]))

图片去重器

duplication_filter = set()

请求头

headers = { 'accept-encoding': 'gzip, deflate, br', 'accept-language': 'zh-CN,zh;q=0.9', 'user-agent': 'Mozilla/5.0 (Linux; Android 4.0.4; Galaxy Nexus Build/IMM76B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.76 Mobile Safari/537.36', 'accept': ' / ', 'referer': 'https://www.google.com/', 'authority': 'www.google.com', }

重试装饰器

def try_again_while_except(max_times=3): """ 当出现异常时，自动重试。连续失败max_times次后放弃。 """

def decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        error_cnt = 0
        error_msg = ''
        while error_cnt < max_times:
            try:
                return func(*args, **kwargs)
            except Exception as e:
                error_msg = str(e)
                error_cnt += 1
        if error_msg:
            logging.error(error_msg)

    return wrapper

return decorator

@try_again_while_except() def download_image(session, image_url, image_class): """ 从给定的url中下载图片，并保存到指定路径 """ # 下载图片 resp = session.get(image_url, timeout=20) # 检查图片是否下载成功 if resp.status_code != 200: raise Exception('Response Status Code {}！'.format(resp.status_code)) # 分配一个图片编号 image_index = images_index_map.get(image_class, 0) # 更新待分配编号 images_index_map[image_class] = image_index + 1 # 拼接图片路径 image_path = os.path.join(images_root, image_class, '{}.jpg'.format(image_index)) # 保存图片 with open(image_path, 'wb') as f: f.write(resp.content) # 成功写入了一张图片 return True

@try_again_while_except() def get_and_analysis_google_search_page(session, page, image_class, keyword): """ 使用google进行搜索，下载搜索结果页面，解析其中的图片地址，并对有效图片进一步发起请求 """ logging.info('Class:{} Page:{} Processing...'.format(image_class, page + 1)) # 记录从本页成功下载的图片数量 downloaded_cnt = 0 # 构建请求参数 params = ( ('q', keyword), ('tbm', 'isch'), ('async', '_id:islrg_c,_fmt:html'), ('asearch', 'ichunklite'), ('start', str(page * 100)), ('ijn', str(page)), ) # 进行搜索 resp = requests.get('https://www.google.com/search', params=params, timeout=20) # 解析搜索结果 bsobj = BeautifulSoup(resp.content, 'lxml') divs = bsobj.find_all('div', {'class': 'islrtb isv-r'}) for div in divs: image_url = div.get('data-ou') # 只有当图片以'.jpg','.jpeg','.png'结尾时才下载图片 if image_url.endswith('.jpg') or image_url.endswith('.jpeg') or image_url.endswith('.png'): # 过滤掉相同图片 if image_url not in duplication_filter: # 使用去重器记录 duplication_filter.add(image_url) # 下载图片 flag = download_image(session, image_url, image_class) if flag: downloaded_cnt += 1 logging.info('Class:{} Page:{} Done. {} images downloaded.'.format(image_class, page + 1, downloaded_cnt))

def search_with_google(image_class, keyword): """ 通过google下载数据集 """ # 创建session对象 session = requests.session() session.headers.update(headers) # 每个类别下载10页数据 for page in range(download_pages): get_and_analysis_google_search_page(session, page, image_class, keyword)

def run(): # 首先，创建数据文件夹 if not os.path.exists(images_root): os.mkdir(images_root) for sub_images_dir in keywords_map.keys(): # 对于每个图片类别都创建一个单独的文件夹保存 sub_path = os.path.join(images_root, sub_images_dir) if not os.path.exists(sub_path): os.mkdir(sub_path) # 开始下载，这里使用gevent的协程池进行并发 pool = Pool(len(keywords_map)) for image_class, keyword in keywords_map.items(): pool.spawn(search_with_google, image_class, keyword) pool.join()

if name == ' main ': run()

```

项目中涉及到的所有配置参数，都提取到了settings.py中，内容如下，以供查阅：

```python

- - coding: utf-8 - -

@File : settings.py

@Author : AaronJny

@Time : 2019/12/16

@Desc :

##########爬虫

图片类别和搜索关键词的映射关系

IMAGE_CLASS_KEYWORD_MAP = { 'cats': '宠物猫', 'dogs': '宠物狗', 'mouses': '宠物鼠', 'rabbits': '宠物兔' }

图片保存根目录

IMAGES_ROOT = './images'

爬虫每个类别下载多少页图片

SPIDER_DOWNLOAD_PAGES = 20

#########数据

每个类别选取的图片数量

SAMPLES_PER_CLASS = 345

参与训练的类别

CLASSES = ['cats', 'dogs', 'mouses', 'rabbits']

参与训练的类别数量

CLASS_NUM = len(CLASSES)

类别->编号的映射

CLASS_CODE_MAP = { 'cats': 0, 'dogs': 1, 'mouses': 2, 'rabbits': 3 }

编号->类别的映射

CODE_CLASS_MAP = { 0: '猫', 1: '狗', 2: '鼠', 3: '兔' }

随机数种子

RANDOM_SEED = 13 # 四个类别时样本较为均衡的随机数种子

RANDOM_SEED = 19 # 三个类别时样本较为均衡的随机数种子

训练集比例

TRAIN_DATASET = 0.6

开发集比例

DEV_DATASET = 0.2

测试集比例

TEST_DATASET = 0.2

mini_batch大小

BATCH_SIZE = 16

imagenet数据集均值

IMAGE_MEAN = [0.485, 0.456, 0.406]

imagenet数据集标准差

IMAGE_STD = [0.299, 0.224, 0.225]

#########训练

学习率

LEARNING_RATE = 0.001

训练epoch数

TRAIN_EPOCHS = 30

保存训练模型的路径

MODEL_PATH = './model.h5'

########Web

Web服务端口

WEB_PORT = 5000

```

爬虫使用Google进行图片搜索，每个宠物搜索10页，下载其中的所有图片。当爬虫运行完成后，项目下会多出一个images文件夹，点进去有四个子文件夹，分别为cats、dogs、mouses、rabbits。每一个子文件夹里面是对应类别的宠物图片。

其中猫图片600+张，狗图片600+张，鼠图片400+张，兔图片500+张。花二十多分钟时间，过一遍全部图片，剔除其中不符合要求的图片。注意，这一步是必做的，而且要认真对待，我吃了亏的= =

进行一轮筛选后，剩下图片张数：

宠物	图片数量
猫	521
狗	526
鼠	346
兔	345

考虑各类别样本均衡的问题，无非是过采样和欠采样。因为是图片数据，也可以使用数据增强的手段，为图片数量较少的类别生成一些图片，使样本数量均衡。但出于如下原因考虑，我直接做了欠采样，即每个类别只选取了345张样本：

使用数据增强的话，需要在原图片的基础上，重新生成一份数据集，嫌麻烦……
使用数据增强后，样本数量比较多，无法同时读取到内存里面，只能写个生成器，处理哪一部分的时候，实时从硬盘读取。

弊端有俩：①频繁读取硬盘，肯定比不上所有数据都放在内存里面，会拖慢训练速度；②还是嫌麻烦……

说到底就是自己太懒了……当然，可想而知，使用数据增强（在这里，数据增强可以作为一种过采样的方式）使数据样本都达到526，训练的效果肯定会更好，能好多少就不知道了，有兴趣的可以自行实现，没啥难点，就是麻烦点。

下面该对数据做预处理了。很多经典的模型接收的输入格式都为(None,224,224,3)，由于我们的样本较少，不可避免地需要用到迁移学习，所以我们的数据格式与经典模型保持一致，也使用(None,224,224,3)，下面是预处理过程：

```python

- - coding: utf-8 - -

@File : data.py

@Author : AaronJny

@Time : 2019/12/16

@Desc :

import os import random import tensorflow as tf import settings

每个类别选取的图片数量

samples_per_class = settings.SAMPLES_PER_CLASS

图片根目录

images_root = settings.IMAGES_ROOT

类别->编码的映射

class_code_map = settings.CLASS_CODE_MAP

我们准备使用经典网络在imagenet数据集上的与训练权重，所以归一化时也要使用imagenet的平均值和标准差

image_mean = tf.constant(settings.IMAGE_MEAN) image_std = tf.constant(settings.IMAGE_STD)

def normalization(x): """ 对输入图片x进行归一化，返回归一化的值 """ return (x - image_mean) / image_std

def train_preprocess(x, y): """ 对训练数据进行预处理。注意，这里的参数x是图片的路径，不是图片本身；y是图片的标签值 """ # 读取图片 x = tf.io.read_file(x) # 解码成张量 x = tf.image.decode_jpeg(x, channels=3) # 将图片缩放到[244,244]，比输入[224,224]稍大一些，方便后面数据增强 x = tf.image.resize(x, [244, 244]) # 随机决定是否左右镜像 if random.choice([0, 1]): x = tf.image.random_flip_left_right(x) # 随机从x中剪裁出(224,224,3)大小的图片 x = tf.image.random_crop(x, [224, 224, 3]) # 读完上面的代码可以发现，这里的数据增强并不增加图片数量，一张图片经过变换后， # 仍然只是一张图片，跟我们前面说的增加图片数量的逻辑不太一样。 # 这么做主要是应对我们的数据集里可能会存在相同图片的情况。

# 将图片的像素值缩放到[0,1]之间
x = tf.cast(x, dtype=tf.float32) / 255.
# 归一化
x = normalization(x)

# 将标签转成one-hot形式
y = tf.cast(y, dtype=tf.int32)
y = tf.one_hot(y, settings.CLASS_NUM)

return x, y

def dev_preprocess(x, y): """ 对验证集和测试集进行数据预处理的方法。和train_preprocess的主要区别在于，不进行数据增强，以保证验证结果的稳定性。 """ # 读取并缩放图片 x = tf.io.read_file(x) x = tf.image.decode_jpeg(x, channels=3) x = tf.image.resize(x, [224, 224]) # 归一化 x = tf.cast(x, dtype=tf.float32) / 255. x = normalization(x) # 将标签转成one-hot形式 y = tf.cast(y, dtype=tf.int32) y = tf.one_hot(y, settings.CLASS_NUM)

return x, y

(图片路径,标签)的列表

image_path_and_labels = []

排序，保证每次拿到的顺序都一样

sub_images_dir_list = sorted(list(os.listdir(images_root)))

遍历每一个子目录

for sub_images_dir in sub_images_dir_list: sub_path = os.path.join(images_root, sub_images_dir) # 如果给定路径是文件夹,并且这个类别参与训练 if os.path.isdir(sub_path) and sub_images_dir in settings.CLASSES: # 获取当前类别的编码 current_label = class_code_map.get(sub_images_dir) # 获取子目录下的全部图片名称 images = sorted(list(os.listdir(sub_path))) # 随机打乱(排序和置随机数种子都是为了保证每次的结果都一样) random.seed(settings.RANDOM_SEED) random.shuffle(images) # 保留前settings.SAMPLES_PER_CLASS个 images = images[:samples_per_class] # 构建(x,y)对 for image_name in images: abs_image_path = os.path.join(sub_path, image_name) image_path_and_labels.append((abs_image_path, current_label))

计算各数据集样例数

total_samples = len(image_path_and_labels) # 总样例数 train_samples = int(total_samples * settings.TRAIN_DATASET) # 训练集样例数 dev_samples = int(total_samples * settings.DEV_DATASET) # 开发集样例数 test_samples = total_samples - train_samples - dev_samples # 测试集样例数

打乱数据集

random.seed(settings.RANDOM_SEED) random.shuffle(image_path_and_labels)

将图片数据和标签数据分开，此时它们仍是一一对应的

x_data = tf.constant([img for img, label in image_path_and_labels]) y_data = tf.constant([label for img, label in image_path_and_labels])

开始划分数据集

训练集

train_db = tf.data.Dataset.from_tensor_slices((x_data[:train_samples], y_data[:train_samples]))

打乱顺序，数据预处理，设置批大小

train_db = train_db.shuffle(10000).map(train_preprocess).batch(settings.BATCH_SIZE)

开发集(验证集)

dev_db = tf.data.Dataset.from_tensor_slices( (x_data[train_samples:train_samples + dev_samples], y_data[train_samples:train_samples + dev_samples]))

数据预处理，设置批大小

dev_db = dev_db.map(dev_preprocess).batch(settings.BATCH_SIZE)

测试集

test_db = tf.data.Dataset.from_tensor_slices( (x_data[train_samples + dev_samples:], y_data[train_samples + dev_samples:]))

数据预处理，设置批大小

test_db = test_db.map(dev_preprocess).batch(settings.BATCH_SIZE)

```

二、模型构建、训练和调优

数据已经全部处理完毕，该考虑模型了。首先，我们数据集太小了，直接构建自己的网络并训练，并不是一个好方案。因为这几种宠物其实挺难区分的，所以模型需要有一定复杂度，才能很好拟合这些数据，但我们的数据又太少了，最后的结果一定是过拟合，而且还是救不回来的那种= =所以我们考虑从迁移学习入手。

什么是迁移学习？懒得重新组织语言的我，默默地从之前写的博文里面摘了一段：

一般认为，深度卷积神经网络的训练是对数据集特征的一步步抽取的过程，从简单的特征，到复杂的特征。训练好的模型学习到的是对图像特征的抽取方法，所以在imagenet数据集上训练好的模型理论上来说，也可以直接用于抽取其他图像的特征，这也是迁移学习的基础。自然，这样的效果往往没有在新数据上重新训练的效果好，但能够节省大量的训练时间，在特定情况下非常有用。

上面说的特定情况也包括我们面临的这一种——用于实际问题的数据集过小。

说到迁移学习，我最先想到的是VGG16，就先用VGG16搞了一波。使用在imagenet数据集上预训练的VGG16网络，去除顶部的全连接层，冻结全部参数，使它们在接下来的训练中不会改变。然后加上自己的全连接层，最后的输出层节点为4，对应于我们的四分类问题。开始训练。

模型在训练集上的误差很快降到5%以下，但是在验证集上的准确率基本在70+%，很明显，过拟合了。好嘛，盘它！主要使用如下方法尝试解决过拟合问题：

调节全连接层的层数和每层的节点数
添加BN层(虽说不是为了解决过拟合问题诞生的，但一定程度上是有效果的)
添加Dropout层
调节Dropout Rate
添加l2正则

一顿操作猛如虎，回头一看0-5。这些方法确实对过拟合有所缓解，验证集上的准确率也确实有所提升，但只能达到81%左右。

然后我尝试了Resnet50，当然也过拟合了，盘它！最后验证集accuracy能达到83%左右。

很明显了，在全连接层的调整意义不大，究其根本，在于VGG16和ResNet50去除了全连接层之后，参数的数量也达到了20M+。两千万的参数使得模型严重过拟合，所以我们需要换一个参数少一点的模型。

于是，我盯上了DenseNet121，它的参数数量只有7M。继续盘它！果然，在一段时间的调优后，模型的性能有了明显的提升，验证集上的accuracy达到了87%左右。虽然和ResNet相比，准确率只高了4%，但相比于ResNet50 96%的训练accuracy而言，DenseNet121的训练accuracy只有90%左右。也就是说，对于DenseNet121而言，这个问题已经不再是过拟合问题了（相差3%我是可以接受的），而是欠拟合了。

然而淡腾的是，再怎么调参，模型都很难继续拟合了，调小学习率也不行。模型本身没啥问题的话，我开始怀疑数据集有没有问题，毕竟这种无法拟合的问题有很大概率是数据导致的。于是我就去检查了一下数据集……

这就是我前面强调认真过一遍数据集的原因了，我当时只是花个几分钟粗略地过了一下，删除掉一些明显不对的图片。我第二次认真过数据集的时候才发现，有很多异常图片没有过滤掉，比如猫的目录下有狗的图片，狗的目录下有猫的图片，还有一些不同动物同框的图片，以及我自己都认不出来的图片……

文章第一部分中各类图片数量的表格，其实就是我第二遍过滤后的结果统计。

过滤完成后，模型的性能有了明显的提升，训练accuracy约为93%-94%，验证accuracy为94%，测试accuracy为92%.我们先来看一下代码，后面会对这个结果再进行分析。

首先，是模型的构建：

```python

- - coding: utf-8 - -

@File : models.py

@Author : AaronJny

@Time : 2019/12/16

@Desc :

import tensorflow as tf import settings

def my_densenet(): """ 创建并返回一个基于densenet的Model对象 """ # 获取densenet网络，使用在imagenet上训练的参数值，移除头部的全连接网络，池化层使用max_pooling densenet = tf.keras.applications.DenseNet121(include_top=False, weights='imagenet', pooling='max') # 冻结预训练的参数，在之后的模型训练中不会改变它们 densenet.trainable = False # 构建模型 model = tf.keras.Sequential([ # 输入层，shape为(None,224,224,3) tf.keras.layers.Input((224, 224, 3)), # 输入到DenseNet121中 densenet, # 将DenseNet121的输出展平，以作为全连接层的输入 tf.keras.layers.Flatten(), # 添加BN层 tf.keras.layers.BatchNormalization(), # 随机失活 tf.keras.layers.Dropout(0.5), # 第一个全连接层，激活函数relu tf.keras.layers.Dense(512, activation=tf.nn.relu), # BN层 tf.keras.layers.BatchNormalization(), # 随机失活 tf.keras.layers.Dropout(0.5), # 第二个全连接层，激活函数relu tf.keras.layers.Dense(64, activation=tf.nn.relu), # BN层 tf.keras.layers.BatchNormalization(), # 输出层，为了保证输出结果的稳定，这里就不添加Dropout层了 tf.keras.layers.Dense(settings.CLASS_NUM, activation=tf.nn.softmax) ])

return model

if name == ' main ': model = my_densenet() model.summary()

```

网络的summary:

```python Model: "sequential"

Layer (type) Output Shape Param #

densenet121 (Model) (None, 1024) 7037504

flatten (Flatten) (None, 1024) 0

batch_normalization (BatchNo (None, 1024) 4096

dropout (Dropout) (None, 1024) 0

dense (Dense) (None, 512) 524800

batch_normalization_1 (Batch (None, 512) 2048

dropout_1 (Dropout) (None, 512) 0

dense_1 (Dense) (None, 64) 32832

batch_normalization_2 (Batch (None, 64) 256

dense_2 (Dense) (None, 4) 260

Total params: 7,601,796 Trainable params: 561,092 Non-trainable params: 7,040,704

```

参数总量7601796个，其中可训练参数561092个。

模型和数据都已准备完毕，可以开始训练了。让我们编写一个训练用的脚本：

```python

- - coding: utf-8 - -

@File : train.py

@Author : AaronJny

@Time : 2019/12/17

@Desc :

import tensorflow as tf from data import train_db, dev_db import models import settings

从models文件中导入模型

model = models.my_densenet() model.summary()

配置优化器、损失函数、以及监控指标

model.compile(tf.keras.optimizers.Adam(settings.LEARNING_RATE), loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy'])

在每个epoch结束后尝试保存模型参数，只有当前参数的val_accuracy比之前保存的更优时，才会覆盖掉之前保存的参数

model_check_point = tf.keras.callbacks.ModelCheckpoint(filepath=settings.MODEL_PATH, monitor='val_accuracy', save_best_only=True)

使用tf.keras的高级接口进行训练

model.fit_generator(train_db, epochs=settings.TRAIN_EPOCHS, validation_data=dev_db, callbacks=[model_check_point])

```

现在，我们可以运行脚本进行训练了，最优的参数将被保存在settings.MODEL_PATH。训练完成后，我们需要调用验证脚本，验证下模型在验证集和测试集上的表现：

```python

- - coding: utf-8 - -

@File : eval.py

@Author : AaronJny

@Time : 2019/12/17

@Desc :

import tensorflow as tf from data import dev_db, test_db from models import my_densenet import settings

创建模型

model = my_densenet()

加载参数

model.load_weights(settings.MODEL_PATH)

因为想用tf.keras的高级接口做验证，所以还是需要编译模型

model.compile(tf.keras.optimizers.Adam(settings.LEARNING_RATE), loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy'])

验证集accuracy

print('dev', model.evaluate(dev_db))

测试集accuracy

print('test', model.evaluate(test_db))

```

输出如下:

python 18/18 [==============================] - 5s 304ms/step - loss: 0.1936 - accuracy: 0.9457 dev [0.19364455559601387, 0.9456522] 18/18 [==============================] - 1s 64ms/step - loss: 0.2666 - accuracy: 0.9203 test [0.26657224384446937, 0.9202899]

能够看到，模型在验证集上的准确率为94.57%，在测试集上的准确率为92.03%，已经达到我的心里预期了，毕竟这么少的数据，还要啥自行车？

随着训练epoch的增多，模型的训练accuracy始终在[0.92,0.95]左右徘徊不定，没法继续拟合。究其原因，应该还是数据的锅。我们看一下识别错的样本，在eval.py脚本中，增加下面这一段程序：

```python

查看识别错误的数据

for x, y in test_db: y_pred = model(x) y_pred = tf.argmax(y_pred, axis=1).numpy() y_true = tf.argmax(y, axis=1).numpy() batch_size = y_pred.shape[0] for i in range(batch_size): if y_pred[i] != y_true[i]: print('{} 被错误识别成 {}!'.format(settings.CODE_CLASS_MAP[y_true[i]], settings.CODE_CLASS_MAP[y_pred[i]]))

```

重新跑一下eval.py脚本，输出如下：

python 18/18 [==============================] - 5s 291ms/step - loss: 0.1936 - accuracy: 0.9457 dev [0.19364455559601387, 0.9456522] 18/18 [==============================] - 1s 64ms/step - loss: 0.2666 - accuracy: 0.9203 test [0.26657224384446937, 0.9202899] 狗被错误识别成兔! 狗被错误识别成兔! 狗被错误识别成兔! 鼠被错误识别成兔! 狗被错误识别成猫! 鼠被错误识别成猫! 狗被错误识别成兔! 狗被错误识别成鼠! 鼠被错误识别成兔! 狗被错误识别成兔! 猫被错误识别成兔! 猫被错误识别成鼠! 猫被错误识别成兔! 鼠被错误识别成兔! 狗被错误识别成兔! 狗被错误识别成猫! 鼠被错误识别成兔! 狗被错误识别成兔! 鼠被错误识别成兔! 狗被错误识别成猫! 鼠被错误识别成兔! 狗被错误识别成兔!

来，跟我一起唱——都是兔子惹的祸～

能够看到，出错的大部分都是被误识别成兔子了。对应到数据集上，虽然已经删掉了部分问题比较大的图片，但兔子的图片确实不好认。有很多兔子图片我人工分辨都认不出是兔子（捂脸.jpg）。然后，有些兔子图片看起来很像猫，有些看起来很像狗，有些看起来很像鼠……

如果我们把兔子图片去掉，将系统改为三分类问题，准确度将大幅度提高。当然了，按理说识别的类别数量变了，除了调整输出层的节点数量外，要想取得最佳效果，模型的其他参数也需要做相应调整的。我自己已经实测了，但限于篇幅，就不演示了，如果有兴趣的话，可以直接在settings.py里进行调整，将它变为三分类问题。改这两个地方：

```python

参与训练的类别

CLASSES = ['cats', 'dogs', 'mouses', 'rabbits']

随机数种子

RANDOM_SEED = 13 # 四个类别时样本较为均衡的随机数种子

```

```python

参与训练的类别

CLASSES = ['cats', 'dogs', 'mouses']

随机数种子

RANDOM_SEED = 19 # 三个类别时样本较为均衡的随机数种子 ```

然后重新训练和验证即可。这只是一个插曲，本文仍然以四分类问题继续说明后续内容。

三、Web接口编写

模型训练好了，我们要把它应用起来。我准备编写一个Web服务，用户可以通过浏览器上传一张图片，服务器判断此图片的类别后，返回相关数据给用户。Web后端使用Flask，小而轻，前端则选用Vue.js + Element-UI实现。

先写后端：

```python

- - coding: utf-8 - -

@File : app.py

@Author : AaronJny

@Time : 2019/12/18

@Desc :

from flask import Flask from flask import jsonify from flask import request, render_template import tensorflow as tf from models import my_densenet import settings

app = Flask( name )

导入模型

model = my_densenet()

加载训练好的参数

model.load_weights(settings.MODEL_PATH)

@app.route('/', methods=['GET']) def index(): """ 首页，vue入口 """ return render_template('index.html')

@app.route('/api/v1/pets_classify/', methods=['POST']) def pets_classify(): """ 宠物图片分类接口，上传一张图片，返回此图片上的宠物是那种类别，概率多少 """ # 获取用户上传的图片 img_str = request.files.get('file').read() # 进行数据预处理 x = tf.image.decode_image(img_str, channels=3) x = tf.image.resize(x, (224, 224)) x = x / 255. x = (x - tf.constant(settings.IMAGE_MEAN)) / tf.constant(settings.IMAGE_STD) x = tf.reshape(x, (1, 224, 224, 3)) # 预测 y_pred = model(x) pet_cls_code = tf.argmax(y_pred, axis=1).numpy()[0] pet_cls_prob = float(y_pred.numpy()[0][pet_cls_code]) pet_cls_prob = '{}%'.format(int(pet_cls_prob * 100)) pet_class = settings.CODE_CLASS_MAP.get(pet_cls_code) # 将预测结果组织成json res = { 'code': 0, 'data': { 'pet_cls': pet_class, 'probability': pet_cls_prob, 'msg': '

{} 概率 {} '.format(pet_class, pet_cls_prob), } } # 返回json数据 return jsonify(res)

if name == ' main ': app.run(port=settings.WEB_PORT)

```

后端脚本app.py很简单，主要就两个方法。其中index方法会返回首页的html源码，是用户在浏览器端的访问入口；另一个方法pets_classify则提供了计算给定图片类别的功能。

前端文件index.html主要是提供了一个照片墙，用户上传图片到照片墙，服务器就会计算图片类别并返回相关数据。代码如下：

```html

宠物识别Demo

```

让我们试试效果。首先，运行app.py脚本，启动web服务，当你看到如下输出时，说明服务启动成功了：

sh * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit) * Serving Flask app "app" (lazy loading) * Environment: production WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Debug mode: off

因为只是开发环境，这么启动就可以了。如果是生产环境，请不要这么做，可以选择使用nginx + gunicorn +uWSGI + gevent进行部署。