引言

首先，我们看几张图片：

作为人类，我们很轻松就能识别出第一张是猫，后两张是狗。为什么我们知道呢？因为从小我们的爸妈，我们的老师，周围的所有人都指着狗对我们说它是狗，指着猫对我们说它是猫。换句话来说，是别人教我们的，所以我们现在才能识别出猫狗。而对于计算机呢？没有人教它，这些丰富多彩的图片在它眼里，无非都是一个个像素点构成的数字矩阵。该怎么让他识别出来呢？这就是今天所用的卷积神经网络。

1.什么是卷积神经网络？

1.1什么是神经网络？

顾名思义，神经网络是类似于人脑神经元的一种东西。学过生物的我们都知道，神经元彼此之间相互联系，传入一个信号后，可以在神经元之间不断传递，最终促使肌体做出反应，比如被针扎了之后会马上缩手。你也可以笼统的认为神经网络就是一个函数，传入一个或多个参数后，经过一系列变换，输出一个或多个参数。最简单的以y=x+1为例，传入一个值就能输出一个值，当传入x=2的时候输出3，x=3的时候输出4。不过，真正的神经网络要复杂的多。这里以BP神经网络为例：

目前，你只需要知道神经网络是一个大函数就行，传入输入，传出输出。

想要继续深入学习可以参考：到底什么是神经网络？

1.2什么是卷积？

首先，给出卷积的公式：

积看出来了，f（t）和g（t）的积，那卷在哪里呢？笔者认为，卷在两个方面：

第一卷是如果将f（t）和g（t）的图像放在同一垂直面上，对应点之间的连线是相互交织在一起的，如果将g函数翻转一下，是不是就舒服很多了呢？

第二卷是g函数不等于卷积核，g函数要旋转180度之后才是卷积核。

可参考：卷积神经网络卷在哪里？

2.准备工作

2.1一些知识：

1.眼睛只完成图像的摄取功能，识别的关键在于人脑。而人脑对图像的识别是层层抽像的。

2.人工神经元及神经网络模拟了大脑的神经元及其连接。

3.计算机看到的图片是一个个代表明暗的数字。彩色图片是由RGB三色组成的。

4.神经网络需要训练来得到最佳的模型参数。

5.卷积神经网络主要的设计思想是更好的利用图片的性质。

图片的模式比图片小的多
图片中的模式出现在图像的不同区域
缩放不影响图片中的物体

6.卷积层就是在图片中扫描特征

7.最大池化层就是在缩放图片，减少参数。

8.多次的卷积和池化后，再经过flatten连接一个全连接层

2.2keras

keras是一个用python编写的高级神经网络APL
sequential模型

1. import keras
2. from keras import layers
3. model = keras.Sequential()  #建立模型
4. model.add(layers.Dense(20,activation="relu",input_shape=(10,))) # 加了一个全连接层 (神经元数量，激活函数，输入的参数值数量：10个参数）
5. model.add(layers.Dense(20,activation="relu"))  # 再加一个全连接层
6. model.add(layers.Dense(10,activation="softmax")) # 同上
7. model.fit(x,y,epochs=10,batch_size=32)  #模型训练： x是图片，y是图形标签 epochs：每张图片看、训练10遍 batch_size:一次只传入32张图片

keras. Sequential() 建立函数
model.add（）添加层
model.fit() 训练模型

2.3Conv2D

keras.layers.Conv2D(filters,kernel_size,strides=(1,1),padding="valid",data_formt=None))

filters:整数，输出空间的维度，卷积核的数量
kernel_size:一个整数，或者2个整数代表的元组或列表，指明2D卷积窗口的宽度和高度，可以是一个整数，为所有空间维度指定相同的值。
strides：一个整数，或者2个整数代表的元组或列表，指明卷积沿宽度和高度方向的步长。可以是一个整数，为所有空间维度指定相同的值。
padding："valid"或者"same",大小写敏感，用于边缘处理部分。

2.4 MaxPooling2D

keras.layers.MaxPooling2D(pool_size=(2,2),strides=None,padding="valid",data_format =None)

pool_size:整数，或者2个整数表示的元组，沿（垂直，水平）方向缩小比例的因数。（2,2）会把输入张量的两个维度都缩小一半。如果只使用一个整数，那么两个维度都会使用同样的窗口长度。
strides:整数，2个整数表示的元组，或者是None。表示步长值。如果是None，那么默认值是pool_size。
padding:"valid"或者“same"

3.基于卷积神经网络的猫狗识别

3.1导入必要库

1. import sys
2. from matplotlib import pyplot
3. from keras.utils import to_categorical
4. from keras.models import Sequential
5. from keras.layers import Conv2D
6. from keras.layers import MaxPool2D
7. from keras.layers import Dense
8. from keras.layers import Flatten
9. from keras.optimizers import SGD
10. from keras.preprocessing.image import ImageDataGenerator
11. from keras.models import load_model
12. import tensorflow as tf
13. tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)

这一部分自己安装就可以，pip install 对应库名，受网络问题可能会有点慢。

3.2模型定义

1. def define_cnn_model():
2. # 使用Sequential序列模型
3.     model = Sequential()
4. # 卷积层
5.     model.add(Conv2D(32,(3,3),activation="relu",padding="same",input_shape=(200,200,3)))  # 第一层即为卷积层，要设置输入进来图片的样式  3是颜色通道个数
6. # 最大池化层
7.     model.add(MaxPool2D((2,2)))  # 池化窗格
8. # Flatten层
9.     model.add(Flatten())
10. # 全连接层
11.     model.add(Dense(128,activation="relu"))  # 128为神经元的个数
12.     model.add(Dense(1,activation="sigmoid"))
13. # 编译模型
14.     opt = SGD(lr= 0.001,momentum=0.9)  # 随机梯度
15.     model.compile(optimizer=opt,loss="binary_crossentropy",metrics=["accuracy"])
16. return model

首先创建一个Sequential模型

添加一个卷积层，第一个参数是卷积核的数量，第二个是卷积核的规格，（3,3）即为3*3的，第三个参数是激活函数类型，第四个是边缘的处理办法，第五个因为第一层即为卷积层，要定义输入图片的规格（200，200,3）即为200*200,3说明是彩色图片。

再添加一个池化层，（2,2）说明每2*2化作一个窗格。

再添加一个Flatten层，将池化后的结果展开；

再添加一个全连接层，第一个参数是神经元个数，第二个参数是激活函数的类型；

最后再添加一个全连接层输出结果，注意我们的结果需判断猫狗就行，因此一个神经元就行。

最后用随机梯度编译模型，这一块感兴趣的同学可以自己查阅资料学习。

3.3实例化模型并训练

1. def train_cnn_model():
2. # 实例化模型
3.     model = define_cnn_model()
4. # 创建图片生成器
5.     datagen = ImageDataGenerator(rescale=1.0/255.0)
6.     train_it = datagen.flow_from_directory(
7. "./ma1ogo3ushu4ju4ji2/dogs_cats/data/train/",
8.         class_mode="binary",
9.         batch_size=64,
10.         target_size=(200, 200))  # batch_size:一次拿出多少张照片 targe_size:将图片缩放到一定比例
11. # 训练模型
12.     model.fit_generator(train_it,
13.                         steps_per_epoch=len(train_it),
14.                         epochs=5,
15.                         verbose=1)
16.     model.save("my_model.h5")

首先调用3.2的函数实例化模型，紧接着创建图片生成器：这个作用就是把文件夹中的图片传入模型中训练，知道就行。里面的参数batch_size是规定一次只能传入64张图片，这样可以有效地避免内存的问题。训练模型中一个重要参数epochs，这里设置为5，说明传入的图片他要学习5次。比如，这里我总共传入了2500张图片，它学习了五次，也就是12500张图片。这样的重复学习，可以有效提高进度，但是当你值调整比较大时，会非常耗时。最后将训练好的模型保存到项目文件夹下。

3.4获取验证的图片

1. def read_random_image():
2.     folder = r"./ma1ogo3ushu4ju4ji2/dogs_cats/data/test/"
3.     file_path = folder + random.choice(os.listdir(folder))
4.     pil_im = Image.open(file_path, 'r')
5. return pil_im

3.5进行验证

1. def get_predict(pil_im,model):
2. # 首先更改图片的大小
3.     name = ''
4.     pil_im = pil_im.resize((200,200))
5. # 将格式转为numpy array格式
6.     array_im = np.asarray(pil_im)
7. # array_im = array_im.resize((4,4))
8.     array_im = array_im[np.newaxis,:]
9. #对图像检测
10.     result = model.predict([[array_im]])
11. if result[0][0]>0.5:
12.         name = "它是狗！"
13. print("预测结果是：狗")
14. else:
15.         name = "它是猫！"
16. print("预测结果是：猫")
17. return name

注意一行代码：

array_im = array_im[np.newaxis,:]

上一行的array_im 是一个三维数组，不符合运行规范，这里要将其转化为四位数组，否则会报错！

3.6显示预测结果

1. pil_im =read_random_image()
2. imshow(np.asarray(pil_im))
3. plt.title(get_predict(pil_im,model))
4. pylab.show()

到这里就大功告成啦！看一下我们的预测结果：

总体来看，预测效果还是不错的，学习次数在5次的情况下，准确度可以达到70%，感兴趣的话，也可以将学习次数调大一点，看看效果！红色警告是由于GPU和CPU的处理问题，你可以暂时忽略。

4.总结

这个猫狗项目只是一个入门项目，但是它的思想很重要。想想看，只要我们有数据，有模型是不是就能让计算机认识任何我们想要认识的东西。手机的人脸识别，支付宝的人脸支付，甚至在未来有没有可能在无人机上装个摄像头去帮我们抓捕犯罪嫌疑人？人工智能的世界很开阔，未来等着我们去探索！

笔者为入门初学者，所以难免会有错误，欢迎大家指正，感兴趣的话可以在评论区一起交流！

5.代码及数据集

第一部分代码为：

1. #!/usr/bin/env python
2. # -*- coding: UTF-8 -*-
3. """
4. @Project ：神经网络猫狗识别 
5. @File    ：CNN.py
6. @IDE     ：PyCharm 
7. @Author  ：咋
8. @Date    ：2022/10/2 10:37 
9. """
10. import sys
11. from matplotlib import pyplot
12. from keras.utils import to_categorical
13. from keras.models import Sequential
14. from keras.layers import Conv2D
15. from keras.layers import MaxPool2D
16. from keras.layers import Dense
17. from keras.layers import Flatten
18. from keras.optimizers import SGD
19. from keras.preprocessing.image import ImageDataGenerator
20. from keras.models import load_model
21. import tensorflow as tf
22. tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
23. 
24. def define_cnn_model():
25. # 使用Sequential序列模型
26.     model = Sequential()
27. # 卷积层
28.     model.add(Conv2D(32,(3,3),activation="relu",padding="same",input_shape=(200,200,3)))  # 第一层即为卷积层，要设置输入进来图片的样式  3是颜色通道个数
29. # 最大池化层
30.     model.add(MaxPool2D((2,2)))  # 池化窗格
31. # Flatten层
32.     model.add(Flatten())
33. # 全连接层
34.     model.add(Dense(128,activation="relu"))  # 128为神经元的个数
35.     model.add(Dense(1,activation="sigmoid"))
36. # 编译模型
37.     opt = SGD(lr= 0.001,momentum=0.9)  # 随机梯度
38.     model.compile(optimizer=opt,loss="binary_crossentropy",metrics=["accuracy"])
39. return model
40. 
41. def train_cnn_model():
42. # 实例化模型
43.     model = define_cnn_model()
44. # 创建图片生成器
45.     datagen = ImageDataGenerator(rescale=1.0/255.0)
46.     train_it = datagen.flow_from_directory(
47. "./ma1ogo3ushu4ju4ji2/dogs_cats/data/train/",
48.         class_mode="binary",
49.         batch_size=64,
50.         target_size=(200, 200))  # batch_size:一次拿出多少张照片 targe_size:将图片缩放到一定比例
51. # 训练模型
52.     model.fit_generator(train_it,
53.                         steps_per_epoch=len(train_it),
54.                         epochs=5,
55.                         verbose=1)
56.     model.save("my_model.h5")
57. train_cnn_model()

第二部分代码：

1. #!/usr/bin/env python
2. # -*- coding: UTF-8 -*-
3. """
4. @Project ：神经网络猫狗识别 
5. @File    ：CNN_test.py
6. @IDE     ：PyCharm 
7. @Author  ：咋
8. @Date    ：2022/10/2 12:12 
9. """
10. 
11. import os,random
12. import matplotlib.pyplot as plt
13. from keras.models import load_model
14. from matplotlib.pyplot import imshow
15. import numpy as np
16. from PIL import Image
17. model_path = "my_model.h5"
18. model = load_model(model_path)
19. import pylab
20. plt.rcParams['font.sans-serif']=['SimHei']
21. def read_random_image():
22.     folder = r"./ma1ogo3ushu4ju4ji2/dogs_cats/data/test/"
23.     file_path = folder + random.choice(os.listdir(folder))
24.     pil_im = Image.open(file_path, 'r')
25. return pil_im
26. 
27. def get_predict(pil_im,model):
28. # 首先更改图片的大小
29.     name = ''
30.     pil_im = pil_im.resize((200,200))
31. # 将格式转为numpy array格式
32.     array_im = np.asarray(pil_im)
33. # array_im = array_im.resize((4,4))
34.     array_im = array_im[np.newaxis,:]
35. #对图像检测
36.     result = model.predict([[array_im]])
37. if result[0][0]>0.5:
38.         name = "它是狗！"
39. print("预测结果是：狗")
40. else:
41.         name = "它是猫！"
42. print("预测结果是：猫")
43. return name
44. pil_im =read_random_image()
45. imshow(np.asarray(pil_im))
46. plt.title(get_predict(pil_im,model))
47. pylab.show()

数据集下载链接：猫狗数据集

视频教学连接：基于卷积神经网络的猫狗识别

基于卷积神经网络(CNN)的猫狗识别

引言