【毕业设计】深度学习动物识别系统 - 图像识别 python OpenCV

---

0 前言

🔥 Hi，大家好，这里是丹成学长的毕设系列文章！

🔥 对毕设有任何疑问都可以问学长哦!

这两年开始，各个学校对毕设的要求越来越高，难度也越来越大… 毕业设计耗费时间，耗费精力，甚至有些题目即使是专业的老师或者硕士生也需要很长时间，所以一旦发现问题，一定要提前准备，避免到后面措手不及，草草了事。

为了大家能够顺利以及最少的精力通过毕设，学长分享优质毕业设计项目，今天要分享的新项目是

🚩 **基于深度学习的动物识别算法 **

🥇学长这里给一个题目综合评分(每项满分5分)

• 难度系数：4分
• 工作量：4分
• 创新点：3分

🧿 选题指导, 项目分享：

https://gitee.com/yaa-dc/BJH/blob/master/gg/cc/README.md

1 课题背景

利用深度学习对野生动物进行自动识别分类,可以大大提高野生动物监测效率,为野生动物保护策略的制定提供可靠的数据支持。但是目前野生动物的自动识别仍面临着监测图像背景信息复杂、质量低造成的识别准确率低的问题,影响了深度学习技术在野生动物保护领域的应用落地。为了实现高准确率的野生动物自动识别，本项目基于卷积神经网络实现图像动物识别。

2 实现效果

3 卷积神经网络

受到人类大脑神经突触结构相互连接的模式启发，神经网络作为人工智能领域的重要组成部分，通过分布式的方法处理信息，可以解决复杂的非线性问题，从构造方面来看，主要包括输入层、隐藏层、输出层三大组成结构。每一个节点被称为一个神经元，存在着对应的权重参数，部分神经元存在偏置，当输入数据ｘ进入后，对于经过的神经元都会进行类似于：y＝w*x＋b的线性函数的计算，其中ｗ为该位置神经元的权值，b则为偏置函数。通过每一层神经元的逻辑运算，将结果输入至最后一层的激活函数，最后得到输出output。

3.1卷积层

卷积核相当于一个滑动窗口，示意图中３x３大小的卷积核依次划过６x６大小的输入数据中的对应区域，并与卷积核滑过区域做矩阵点乘，将所得结果依次填入对应位置即可得到右侧４x４尺寸的卷积特征图，例如划到右上角３x３所圈区域时，将进行０x０＋１x１＋２x１＋１x１＋０x０＋１x１＋１x０＋２x０x１x１＝６的计算操作，并将得到的数值填充到卷积特征的右上角。

3.2 池化层

池化操作又称为降采样，提取网络主要特征可以在达到空间不变性的效果同时，有效地减少网络参数，因而简化网络计算复杂度，防止过拟合现象的出现。在实际操作中经常使用最大池化或平均池化两种方式，如下图所示。虽然池化操作可以有效的降低参数数量，但过度池化也会导致一些图片细节的丢失，因此在搭建网络时要根据实际情况来调整池化操作。

3.3 激活函数：

激活函数大致分为两种，在卷积神经网络的发展前期，使用较为传统的饱和激活函数，主要包括sigmoid函数、tanh函数等；随着神经网络的发展，研宄者们发现了饱和激活函数的弱点，并针对其存在的潜在问题，研宄了非饱和激活函数，其主要含有ReLU函数及其函数变体

3.4 全连接层

在整个网络结构中起到“分类器”的作用，经过前面卷积层、池化层、激活函数层之后，网络己经对输入图片的原始数据进行特征提取，并将其映射到隐藏特征空间，全连接层将负责将学习到的特征从隐藏特征空间映射到样本标记空间，一般包括提取到的特征在图片上的位置信息以及特征所属类别概率等。将隐藏特征空间的信息具象化，也是图像处理当中的重要一环。

3.5 使用tensorflow中keras模块实现卷积神经网络

class CNN(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.conv1 = tf.keras.layers.Conv2D(
            filters=32,             # 卷积层神经元（卷积核）数目
            kernel_size=[5, 5],     # 感受野大小
            padding='same',         # padding策略（vaild 或 same）
            activation=tf.nn.relu   # 激活函数
        )
        self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
        self.conv2 = tf.keras.layers.Conv2D(
            filters=64,
            kernel_size=[5, 5],
            padding='same',
            activation=tf.nn.relu
        )
        self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
        self.flatten = tf.keras.layers.Reshape(target_shape=(7 * 7 * 64,))
        self.dense1 = tf.keras.layers.Dense(units=1024, activation=tf.nn.relu)
        self.dense2 = tf.keras.layers.Dense(units=10)

    def call(self, inputs):
        x = self.conv1(inputs)                  # [batch_size, 28, 28, 32]
        x = self.pool1(x)                       # [batch_size, 14, 14, 32]
        x = self.conv2(x)                       # [batch_size, 14, 14, 64]
        x = self.pool2(x)                       # [batch_size, 7, 7, 64]
        x = self.flatten(x)                     # [batch_size, 7 * 7 * 64]
        x = self.dense1(x)                      # [batch_size, 1024]
        x = self.dense2(x)                      # [batch_size, 10]
        output = tf.nn.softmax(x)
        return output
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

4 inception_v3网络

简介
如果 ResNet 是为了更深，那么 Inception 家族就是为了更宽。Inception 的作者对训练更大型网络的计算效率尤其感兴趣。换句话说：怎样在不增加计算成本的前提下扩展神经网络?

网路结构图

主要改动

• 将7×7卷积分解为3个3×3的卷积。
• 35×35的Inception模块采用图1所示结构，之后采用图5类似结构进行下采样
• 17×17的Inception模块采用图2所示结构，也是采用图5类似结构下采样
• 8×8的Inception模块采用图3所示结构，进行较大维度的提升。

Tensorflow实现代码

import os
import keras
import numpy as np
import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras.models import Model
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True      # TensorFlow按需分配显存
config.gpu_options.per_process_gpu_memory_fraction = 0.5  # 指定显存分配比例


inceptionV3_One={'1a':[64,48,64,96,96,32],
                 '2a':[64,48,64,96,96,64],
                 '3a':[64,48,64,96,96,64]
}


inceptionV3_Two={'1b':[192,128,128,192,128,128,128,128,192,192],
                 '2b':[192,160,160,192,160,160,160,160,192,192],
                 '3b':[192,160,160,192,160,160,160,160,192,192],
                 '4b':[192,192,192,192,192,192,192,192,192,192]
}
keys_two=(list)(inceptionV3_Two.keys())

inceptionV3_Three={
                '1c':[320,384,384,384,448,384,384,384,192],
                '2c':[320,384,384,384,448,384,384,384,192]
}
keys_three=(list)(inceptionV3_Three.keys())

def InceptionV3(inceptionV3_One,inceptionV3_Two,inceptionV3_Three):
    keys_one=(list)(inceptionV3_One.keys())
    keys_two = (list)(inceptionV3_Two.keys())
    keys_three = (list)(inceptionV3_Three.keys())

    input=layers.Input(shape=[299,299,3])

    # 输入部分
    conv1_one = layers.Conv2D(32, kernel_size=[3, 3], strides=[2, 2], padding='valid')(input)
    conv1_batch=layers.BatchNormalization()(conv1_one)
    conv1relu=layers.Activation('relu')(conv1_batch)
    conv2_one = layers.Conv2D(32, kernel_size=[3, 3], strides=[1,1],padding='valid')(conv1relu)
    conv2_batch=layers.BatchNormalization()(conv2_one)
    conv2relu=layers.Activation('relu')(conv2_batch)
    conv3_padded = layers.Conv2D(64, kernel_size=[3, 3], strides=[1,1],padding='same')(conv2relu)
    conv3_batch=layers.BatchNormalization()(conv3_padded)
    con3relu=layers.Activation('relu')(conv3_batch)
    pool1_one = layers.MaxPool2D(pool_size=[3, 3], strides=[2, 2])(con3relu)
    conv4_one = layers.Conv2D(80, kernel_size=[3,3], strides=[1,1], padding='valid')(pool1_one)
    conv4_batch=layers.BatchNormalization()(conv4_one)
    conv4relu=layers.Activation('relu')(conv4_batch)
    conv5_one = layers.Conv2D(192, kernel_size=[3, 3], strides=[2,2], padding='valid')(conv4relu)
    conv5_batch = layers.BatchNormalization()(conv5_one)
    x=layers.Activation('relu')(conv5_batch)

    """
        filter11:1x1的卷积核个数
        filter13:3x3卷积之前的1x1卷积核个数
        filter33:3x3卷积个数
        filter15:使用3x3卷积代替5x5卷积之前的1x1卷积核个数
        filter55:使用3x3卷积代替5x5卷积个数
        filtermax：最大池化之后的1x1卷积核个数
    """
    for i in range(3):
        conv11 = layers.Conv2D((int)(inceptionV3_One[keys_one[i]][0]), kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
        batchnormaliztion11 = layers.BatchNormalization()(conv11)
        conv11relu = layers.Activation('relu')(batchnormaliztion11)

        conv13 = layers.Conv2D((int)(inceptionV3_One[keys_one[i]][1]), kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
        batchnormaliztion13 = layers.BatchNormalization()(conv13)
        conv13relu = layers.Activation('relu')(batchnormaliztion13)
        conv33 = layers.Conv2D((int)(inceptionV3_One[keys_one[i]][2]), kernel_size=[5, 5], strides=[1, 1], padding='same')(conv13relu)
        batchnormaliztion33 = layers.BatchNormalization()(conv33)
        conv33relu = layers.Activation('relu')(batchnormaliztion33)

        conv1533 = layers.Conv2D((int)(inceptionV3_One[keys_one[i]][3]), kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
        batchnormaliztion1533 = layers.BatchNormalization()(conv1533)
        conv1522relu = layers.Activation('relu')(batchnormaliztion1533)
        conv5533first = layers.Conv2D((int)(inceptionV3_One[keys_one[i]][4]), kernel_size=[3, 3], strides=[1, 1], padding='same')(conv1522relu)
        batchnormaliztion5533first = layers.BatchNormalization()(conv5533first)
        conv5533firstrelu = layers.Activation('relu')(batchnormaliztion5533first)
        conv5533last = layers.Conv2D((int)(inceptionV3_One[keys_one[i]][4]), kernel_size=[3, 3], strides=[1, 1], padding='same')(conv5533firstrelu)
        batchnormaliztion5533last = layers.BatchNormalization()(conv5533last)
        conv5533lastrelu = layers.Activation('relu')(batchnormaliztion5533last)

        maxpool = layers.AveragePooling2D(pool_size=[3, 3], strides=[1, 1], padding='same')(x)
        maxconv11 = layers.Conv2D((int)(inceptionV3_One[keys_one[i]][5]), kernel_size=[1, 1], strides=[1, 1], padding='same')(maxpool)
        batchnormaliztionpool = layers.BatchNormalization()(maxconv11)
        convmaxrelu = layers.Activation('relu')(batchnormaliztionpool)

        x=tf.concat([
            conv11relu,conv33relu,conv5533lastrelu,convmaxrelu
        ],axis=3)

    conv1_two = layers.Conv2D(384, kernel_size=[3, 3], strides=[2, 2], padding='valid')(x)
    conv1batch=layers.BatchNormalization()(conv1_two)
    conv1_tworelu=layers.Activation('relu')(conv1batch)

    conv2_two = layers.Conv2D(64, kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
    conv2batch=layers.BatchNormalization()(conv2_two)
    conv2_tworelu=layers.Activation('relu')(conv2batch)
    conv3_two = layers.Conv2D( 96, kernel_size=[3, 3], strides=[1,1], padding='same')(conv2_tworelu)
    conv3batch=layers.BatchNormalization()(conv3_two)
    conv3_tworelu=layers.Activation('relu')(conv3batch)
    conv4_two = layers.Conv2D( 96, kernel_size=[3, 3], strides=[2, 2], padding='valid')(conv3_tworelu)
    conv4batch=layers.BatchNormalization()(conv4_two)
    conv4_tworelu=layers.Activation('relu')(conv4batch)

    maxpool = layers.MaxPool2D(pool_size=[3, 3], strides=[2, 2])(x)
    x=tf.concat([
        conv1_tworelu,conv4_tworelu,maxpool
    ],axis=3)
    """
        filter11:1x1的卷积核个数
        filter13:使用1x3,3x1卷积代替3x3卷积之前的1x1卷积核个数
        filter33:使用1x3,3x1卷积代替3x3卷积的个数
        filter15:使用1x3,3x1，1x3,3x1卷积卷积代替5x5卷积之前的1x1卷积核个数
        filter55:使用1x3,3x1，1x3,3x1卷积代替5x5卷积个数
        filtermax：最大池化之后的1x1卷积核个数
    """
    for i in range(4):
        conv11 = layers.Conv2D((int)(inceptionV3_Two[keys_two[i]][0]), kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
        batchnormaliztion11 = layers.BatchNormalization()(conv11)
        conv11relu=layers.Activation('relu')(batchnormaliztion11)

        conv13 = layers.Conv2D((int)(inceptionV3_Two[keys_two[i]][1]), kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
        batchnormaliztion13 = layers.BatchNormalization()(conv13)
        conv13relu=layers.Activation('relu')(batchnormaliztion13)
        conv3313 = layers.Conv2D((int)(inceptionV3_Two[keys_two[i]][2]), kernel_size=[1, 7], strides=[1, 1], padding='same')(conv13relu)
        batchnormaliztion3313 = layers.BatchNormalization()(conv3313)
        conv3313relu=layers.Activation('relu')(batchnormaliztion3313)
        conv3331 = layers.Conv2D((int)(inceptionV3_Two[keys_two[i]][3]), kernel_size=[7, 1], strides=[1, 1], padding='same')(conv3313relu)
        batchnormaliztion3331 = layers.BatchNormalization()(conv3331)
        conv3331relu=layers.Activation('relu')(batchnormaliztion3331)

        conv15 = layers.Conv2D((int)(inceptionV3_Two[keys_two[i]][4]), kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
        batchnormaliztion15 = layers.BatchNormalization()(conv15)
        conv15relu=layers.Activation('relu')(batchnormaliztion15)
        conv1513first = layers.Conv2D((int)(inceptionV3_Two[keys_two[i]][5]), kernel_size=[1, 7], strides=[1, 1], padding='same')(conv15relu)
        batchnormaliztion1513first = layers.BatchNormalization()(conv1513first)
        conv1513firstrelu=layers.Activation('relu')(batchnormaliztion1513first)
        conv1531second = layers.Conv2D((int)(inceptionV3_Two[keys_two[i]][6]), kernel_size=[7, 1], strides=[1, 1], padding='same')(conv1513firstrelu)
        batchnormaliztion1531second = layers.BatchNormalization()(conv1531second)
        conv1531second=layers.Activation('relu')(batchnormaliztion1531second)
        conv1513third = layers.Conv2D((int)(inceptionV3_Two[keys_two[i]][7]), kernel_size=[1, 7], strides=[1, 1], padding='same')(conv1531second)
        batchnormaliztion1513third = layers.BatchNormalization()(conv1513third)
        conv1513thirdrelu=layers.Activation('relu')(batchnormaliztion1513third)
        conv1531last = layers.Conv2D((int)(inceptionV3_Two[keys_two[i]][8]), kernel_size=[7, 1], strides=[1, 1], padding='same')(conv1513thirdrelu)
        batchnormaliztion1531last = layers.BatchNormalization()(conv1531last)
        conv1531lastrelu=layers.Activation('relu')(batchnormaliztion1531last)

        maxpool = layers.AveragePooling2D(pool_size=[3, 3], strides=[1, 1], padding='same')(x)
        maxconv11 = layers.Conv2D((int)(inceptionV3_Two[keys_two[i]][9]), kernel_size=[1, 1], strides=[1, 1], padding='same')(maxpool)
        maxconv11relu = layers.BatchNormalization()(maxconv11)
        maxconv11relu = layers.Activation('relu')(maxconv11relu)

        x=tf.concat([
            conv11relu,conv3331relu,conv1531lastrelu,maxconv11relu
        ],axis=3)

    conv11_three=layers.Conv2D(192, kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
    conv11batch=layers.BatchNormalization()(conv11_three)
    conv11relu=layers.Activation('relu')(conv11batch)
    conv33_three=layers.Conv2D(320, kernel_size=[3, 3], strides=[2, 2], padding='valid')(conv11relu)
    conv33batch=layers.BatchNormalization()(conv33_three)
    conv33relu=layers.Activation('relu')(conv33batch)

    conv7711_three=layers.Conv2D(192, kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
    conv77batch=layers.BatchNormalization()(conv7711_three)
    conv77relu=layers.Activation('relu')(conv77batch)
    conv7717_three=layers.Conv2D(192, kernel_size=[1, 7], strides=[1, 1], padding='same')(conv77relu)
    conv7717batch=layers.BatchNormalization()(conv7717_three)
    conv7717relu=layers.Activation('relu')(conv7717batch)
    conv7771_three=layers.Conv2D(192, kernel_size=[7, 1], strides=[1, 1], padding='same')(conv7717relu)
    conv7771batch=layers.BatchNormalization()(conv7771_three)
    conv7771relu=layers.Activation('relu')(conv7771batch)
    conv33_three=layers.Conv2D(192, kernel_size=[3, 3], strides=[2, 2], padding='valid')(conv7771relu)
    conv3377batch=layers.BatchNormalization()(conv33_three)
    conv3377relu=layers.Activation('relu')(conv3377batch)

    convmax_three=layers.MaxPool2D(pool_size=[3, 3], strides=[2, 2])(x)
    x=tf.concat([
        conv33relu,conv3377relu,convmax_three
    ],axis=3)
    """
        filter11:1x1的卷积核个数
        filter13:使用1x3,3x1卷积代替3x3卷积之前的1x1卷积核个数
        filter33:使用1x3,3x1卷积代替3x3卷积的个数
        filter15:使用3x3卷积代替5x5卷积之前的1x1卷积核个数
        filter55:使用3x3卷积代替5x5卷积个数
        filtermax：最大池化之后的1x1卷积核个数
        """
    for i in range(2):
        conv11 = layers.Conv2D((int)(inceptionV3_Three[keys_three[i]][0]), kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
        batchnormaliztion11 = layers.BatchNormalization()(conv11)
        conv11relu=layers.Activation('relu')(batchnormaliztion11)

        conv13 = layers.Conv2D((int)(inceptionV3_Three[keys_three[i]][1]), kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
        batchnormaliztion13 = layers.BatchNormalization()(conv13)
        conv13relu=layers.Activation('relu')(batchnormaliztion13)
        conv33left = layers.Conv2D((int)(inceptionV3_Three[keys_three[i]][2]), kernel_size=[1, 3], strides=[1, 1], padding='same')(conv13relu)
        batchnormaliztion33left = layers.BatchNormalization()(conv33left)
        conv33leftrelu=layers.Activation('relu')(batchnormaliztion33left)
        conv33right = layers.Conv2D((int)(inceptionV3_Three[keys_three[i]][3]), kernel_size=[3, 1], strides=[1, 1], padding='same')(conv33leftrelu)
        batchnormaliztion33right = layers.BatchNormalization()(conv33right)
        conv33rightrelu=layers.Activation('relu')(batchnormaliztion33right)
        conv33rightleft=tf.concat([
            conv33leftrelu,conv33rightrelu
        ],axis=3)

        conv15 = layers.Conv2D((int)(inceptionV3_Three[keys_three[i]][4]), kernel_size=[1, 1], strides=[1, 1], padding='same')(x)
        batchnormaliztion15 = layers.BatchNormalization()(conv15)
        conv15relu=layers.Activation('relu')(batchnormaliztion15)
        conv1533 = layers.Conv2D((int)(inceptionV3_Three[keys_three[i]][5]), kernel_size=[3, 3], strides=[1, 1], padding='same')(conv15relu)
        batchnormaliztion1533 = layers.BatchNormalization()(conv1533)
        conv1533relu=layers.Activation('relu')(batchnormaliztion1533)
        conv1533left = layers.Conv2D((int)(inceptionV3_Three[keys_three[i]][6]), kernel_size=[1, 3], strides=[1, 1], padding='same')(conv1533relu)
        batchnormaliztion1533left = layers.BatchNormalization()(conv1533left)
        conv1533leftrelu=layers.Activation('relu')(batchnormaliztion1533left)
        conv1533right = layers.Conv2D((int)(inceptionV3_Three[keys_three[i]][6]), kernel_size=[3, 1], strides=[1, 1], padding='same')(conv1533leftrelu)
        batchnormaliztion1533right = layers.BatchNormalization()(conv1533right)
        conv1533rightrelu=layers.Activation('relu')(batchnormaliztion1533right)
        conv1533leftright=tf.concat([
            conv1533right,conv1533rightrelu
        ],axis=3)

        maxpool = layers.AveragePooling2D(pool_size=[3, 3], strides=[1, 1],padding='same')(x)
        maxconv11 = layers.Conv2D((int)(inceptionV3_Three[keys_three[i]][8]), kernel_size=[1, 1], strides=[1, 1], padding='same')(maxpool)
        batchnormaliztionpool = layers.BatchNormalization()(maxconv11)
        maxrelu = layers.Activation('relu')(batchnormaliztionpool)

        x=tf.concat([
            conv11relu,conv33rightleft,conv1533leftright,maxrelu
        ],axis=3)

    x=layers.GlobalAveragePooling2D()(x)
    x=layers.Dense(1000)(x)
    softmax=layers.Activation('softmax')(x)
    model_inceptionV3=Model(inputs=input,outputs=softmax,name='InceptionV3')
    return model_inceptionV3

model_inceptionV3=InceptionV3(inceptionV3_One,inceptionV3_Two,inceptionV3_Three)
model_inceptionV3.summary()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244

5 最后