0 前言

🔥 优质竞赛项目系列，今天要分享的是

基于深度学习的动物识别算法研究与实现

该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！

🧿 更多资料, 项目分享：

https://gitee.com/dancheng-senior/postgraduate

1 背景

目前，由于计算机能力和相关理论的发展获得了重大突破，基于深度学习的图像检测与识别技术已经广泛应用到人们的生产生活中。学长将深度学习的技术应用到野生动物图像识别中，优化了传统的识别方法，形成对野生动物图像更为准确的识别，为实现高效的野生动物图像识别提供了可能。不同于传统的野生动物识别，基于深度学习的野生动物识别技术可以捕获到野生动物更加细致的信息，有利于对野生动物进行更加准确的识别和研究。因此，对基于深度学习的野生动物识别和研究，可以更好的帮助社会管理者和政府全面有效的对野生动物进行保护和监管，这也正是保护和识别野生动物的关键，同时这对整个自然和社会的和谐发展具有极大的推动作用。

2 算法原理

2.1 动物识别方法概况

基于人工特征的野生动物识别方法主要通过人工对野生动物图像中具有辨识度的特征信息进行提取，并通过特征比对的方式就可以对野生动物所属的类别进行识别判断。

在深度学习技术普及之前，传统的数字图像处理技术与传统机器学习技术一直是研究的热点。传统的数字图像处理技术有模块分割、降低噪声点、边缘检测等方法。传统的机器学习技术有支持向量机、随机森林算法、BP
神经网络算法等。

深度学习技术是通过计算机模拟人类大脑的分层表达结构来建立网络模型，从原始数据集中对相关信息逐层提取。之后通过建立相应的神经网络对数据进行学习和分析，从而提高对目标预测和识别的准确率。如今，深度学习技术已经相对成熟，在对目标进行特征提取方面，卷积神经网络技术逐渐取代了传统的图像处理技术，并且在人类的生产生活中得到了广泛应用，这为研究野生动物更高效的识别方法奠定了基础。

2.2 常用的网络模型

图像识别是指对原始图像进行整体分析来达到预测原始图像所属类别的技术。计算机视觉领域中对图像识别技术进行了优化，与此同时，深度学习技术也对图像识别领域展开了突破。目前在图像识别领域中，研究人员开始使用深度学习的技术，并通过在实际应用中发现，基于深度学习的识别技术比传统的识别技术效果更好，且更具有优势。

2.2.1 B-CNN

双线性卷积神经网络(Bilinear
CNN，B-CNN)[34]是用两个卷积神经网络对图像进行特征提取，然后使用相应的函数将得到所有特征进行组合，组合的数据带入到分类器中进行分类。

2.2.2 SSD

经典的 SSD 模型是由经典网络和特征提取网络组成。

通过引入性能更好的特征提取网络对 SSD
目标检测模型进行了优化。Fu[49]等人提出了增加卷积神经网络层数和深度的方法用于提高识别准确率。通过实际应用之后，发现该方法识别准确率确实得到了一定程度的提高，但是模型结构却越来越复杂，同时对深层次的网络训练也越来越困难。

3 SSD动物目标检测流程

学长首先对 DenseNet-169 网络进行初始化，使用 DenseNet-169 网络作为目标检测的前置网络结构，并运用迁移学习的方法对
DenseNet-169 进行预训练，并将Snapshot Serengeti数据集下的权重值迁移到野生动物检测任务中，使数据集的训练速度得到提升。将
DenseNet-169 作为前置网络置于 SSD 中的目标提取检测网络之前，更换完前置网络的 SSD 目标检测网络依然完整。

4 实现效果

做一个GUI交互界面

5 部分相关代码

5.1 数据预处理

​

    import cv2 as cv
    import os
    import numpy as np
    

    import random
    import pickle
    
    import time
    
    start_time = time.time()
    
    data_dir = './data'
    batch_save_path = './batch_files'
    
    # 创建batch文件存储的文件夹
    os.makedirs(batch_save_path, exist_ok=True)
    
    # 图片统一大小：100 * 100
    # 训练集 20000：100个batch文件，每个文件200张图片
    # 验证集 5000：一个测试文件，测试时 50张 x 100 批次
    
    # 进入图片数据的目录，读取图片信息
    all_data_files = os.listdir(os.path.join(data_dir, 'train/'))
    
    # print(all_data_files)
    
    # 打算数据的顺序
    random.shuffle(all_data_files)
    
    all_train_files = all_data_files[:20000]
    all_test_files = all_data_files[20000:]
    
    train_data = []
    train_label = []
    train_filenames = []
    
    test_data = []
    test_label = []
    test_filenames = []
    
    # 训练集
    for each in all_train_files:
        img = cv.imread(os.path.join(data_dir,'train/',each),1)
        resized_img = cv.resize(img, (100,100))
    
        img_data = np.array(resized_img)
        train_data.append(img_data)
        if 'cat' in each:
            train_label.append(0)
        elif 'dog' in each:
            train_label.append(1)
        else:
            raise Exception('%s is wrong train file'%(each))
        train_filenames.append(each)
    
    # 测试集
    for each in all_test_files:
        img = cv.imread(os.path.join(data_dir,'train/',each), 1)
        resized_img = cv.resize(img, (100,100))
    
        img_data = np.array(resized_img)
        test_data.append(img_data)
        if 'cat' in each:
            test_label.append(0)
        elif 'dog' in each:
            test_label.append(1)
        else:
            raise Exception('%s is wrong test file'%(each))
        test_filenames.append(each)
    
    print(len(train_data), len(test_data))
    
    # 制作100个batch文件
    start = 0
    end = 200
    for num in range(1, 101):
        batch_data = train_data[start: end]
        batch_label = train_label[start: end]
        batch_filenames = train_filenames[start: end]
        batch_name = 'training batch {} of 15'.format(num)
    
        all_data = {
        'data':batch_data,
        'label':batch_label,
        'filenames':batch_filenames,
        'name':batch_name
        }
    
        with open(os.path.join(batch_save_path, 'train_batch_{}'.format(num)), 'wb') as f:
            pickle.dump(all_data, f)
    
        start += 200
        end += 200
    
    # 制作测试文件
    all_test_data = {
        'data':test_data,
        'label':test_label,
        'filenames':test_filenames,
        'name':'test batch 1 of 1'
        }
    
    with open(os.path.join(batch_save_path, 'test_batch'), 'wb') as f:
        pickle.dump(all_test_data, f)
    
    end_time = time.time()
    print('制作结束, 用时{}秒'.format(end_time - start_time))

5.2 构建卷积神经网络

cnn卷积神经网络的编写如下，编写卷积层、池化层和全连接层的代码

​

    conv1_1 = tf.layers.conv2d(x, 16, (3, 3), padding='same', activation=tf.nn.relu, name='conv1_1')
    conv1_2 = tf.layers.conv2d(conv1_1, 16, (3, 3), padding='same', activation=tf.nn.relu, name='conv1_2')
    pool1 = tf.layers.max_pooling2d(conv1_2, (2, 2), (2, 2), name='pool1')
    conv2_1 = tf.layers.conv2d(pool1, 32, (3, 3), padding='same', activation=tf.nn.relu, name='conv2_1')
    conv2_2 = tf.layers.conv2d(conv2_1, 32, (3, 3), padding='same', activation=tf.nn.relu, name='conv2_2')
    pool2 = tf.layers.max_pooling2d(conv2_2, (2, 2), (2, 2), name='pool2')
    conv3_1 = tf.layers.conv2d(pool2, 64, (3, 3), padding='same', activation=tf.nn.relu, name='conv3_1')
    conv3_2 = tf.layers.conv2d(conv3_1, 64, (3, 3), padding='same', activation=tf.nn.relu, name='conv3_2')
    pool3 = tf.layers.max_pooling2d(conv3_2, (2, 2), (2, 2), name='pool3')
    conv4_1 = tf.layers.conv2d(pool3, 128, (3, 3), padding='same', activation=tf.nn.relu, name='conv4_1')
    conv4_2 = tf.layers.conv2d(conv4_1, 128, (3, 3), padding='same', activation=tf.nn.relu, name='conv4_2')
    pool4 = tf.layers.max_pooling2d(conv4_2, (2, 2), (2, 2), name='pool4')
    

    flatten = tf.layers.flatten(pool4)
    fc1 = tf.layers.dense(flatten, 512, tf.nn.relu)
    fc1_dropout = tf.nn.dropout(fc1, keep_prob=keep_prob)
    fc2 = tf.layers.dense(fc1, 256, tf.nn.relu)
    fc2_dropout = tf.nn.dropout(fc2, keep_prob=keep_prob)
    fc3 = tf.layers.dense(fc2, 2, None)

5.3 tensorflow计算图可视化

​

    self.x = tf.placeholder(tf.float32, [None, IMAGE_SIZE, IMAGE_SIZE, 3], 'input_data')
    self.y = tf.placeholder(tf.int64, [None], 'output_data')
    self.keep_prob = tf.placeholder(tf.float32)
    

    # 图片输入网络中
    fc = self.conv_net(self.x, self.keep_prob)
    self.loss = tf.losses.sparse_softmax_cross_entropy(labels=self.y, logits=fc)
    self.y_ = tf.nn.softmax(fc) # 计算每一类的概率
    self.predict = tf.argmax(fc, 1)
    self.acc = tf.reduce_mean(tf.cast(tf.equal(self.predict, self.y), tf.float32))
    self.train_op = tf.train.AdamOptimizer(LEARNING_RATE).minimize(self.loss)
    self.saver = tf.train.Saver(max_to_keep=1)

最后的saver是要将训练好的模型保存到本地。

5.4 网络模型训练

然后编写训练部分的代码，训练步骤为1万步

​

    acc_list = []
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
    

        for i in range(TRAIN_STEP):
            train_data, train_label, _ = self.batch_train_data.next_batch(TRAIN_SIZE)
    
            eval_ops = [self.loss, self.acc, self.train_op]
            eval_ops_results = sess.run(eval_ops, feed_dict={
                self.x:train_data,
                self.y:train_label,
                self.keep_prob:0.7
            })
            loss_val, train_acc = eval_ops_results[0:2]
    
            acc_list.append(train_acc)
            if (i+1) % 100 == 0:
                acc_mean = np.mean(acc_list)
                print('step:{0},loss:{1:.5},acc:{2:.5},acc_mean:{3:.5}'.format(
                    i+1,loss_val,train_acc,acc_mean
                ))
            if (i+1) % 1000 == 0:
                test_acc_list = []
                for j in range(TEST_STEP):
                    test_data, test_label, _ = self.batch_test_data.next_batch(TRAIN_SIZE)
                    acc_val = sess.run([self.acc],feed_dict={
                        self.x:test_data,
                        self.y:test_label,
                        self.keep_prob:1.0
                })
                test_acc_list.append(acc_val)
                print('[Test ] step:{0}, mean_acc:{1:.5}'.format(
                    i+1, np.mean(test_acc_list)
                ))
        # 保存训练后的模型
        os.makedirs(SAVE_PATH, exist_ok=True)
        self.saver.save(sess, SAVE_PATH + 'my_model.ckpt')

训练结果如下：

5.5 对猫狗图像进行2分类

6 最后

🧿 更多资料, 项目分享：

https://gitee.com/dancheng-senior/postgraduate