机器学习 人与马的识别

（一）选题背景：

可以帮助人们更好地管理马匹，提高马术运动和相关产业的工作效率。人与马识别涉及到图像处理、机器学习、深度学习等领域，是计算机视觉技术的经典问题之一。对该问题进行深入研究，可以促进相关领域的技术发展，为其他类似问题提供参考。总体而言，人与马识别是一个具有实际应用价值的问题，具有重要的研究意义和广泛的应用前景。

二）机器学习设计案例设计方案：

从数据网站中下载相关的数据集，对数据集进行整理，在python的环境中，统计数据集中的文件个数，对数据进行预处理，利用keras，构建网络，训练模型，导入图片测试模型

参考来源：kaggle关于标签学习的讨论区

数据集来源：kaggle，网址：https://www.kaggle.com/

1.导入需要的库

 1 import numpy as np
 2 import pandas as pd
 3 import os
 4 import tensorflow as tf
 5 import matplotlib.pyplot as plt
 6 from pathlib import Path
 7 from sklearn.model_selection import train_test_split
 8 from keras.models import Sequential
 9 from keras.layers import Activation
10 from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
11 from keras.applications.resnet import preprocess_input
12 from keras.models import load_model
13 from keras import optimizers

2.查看随机图像

 1 # 导入必要的库
 2 import tensorflow as tf
 3 import matplotlib.pyplot as plt
 4 # 数据目录
 5 data_dir = "C:/Users/horse-or-human/validation"
 6 # 从目录中加载图像数据集
 7 train_ds = tf.keras.preprocessing.image_dataset_from_directory(
 8     data_dir,
 9     validation_split=0.1,  # 验证集占总数据的比例
10     subset="training",  # 使用训练集子集
11     seed=123,  # 随机种子，确保可重复性
12     image_size=(224, 224),  # 图像大小
13     batch_size=32  # 批量大小
14 )
15 # 创建一个大小为10x5的图形窗口
16 plt.figure(figsize=(10, 5))
17 # 从数据集中获取一批图像和标签
18 for images, labels in train_ds.take(1):
19     for i in range(8):
20         # 创建2x4的子图中的一个
21         ax = plt.subplot(2, 4, i + 1)
22         # 显示图像
23         plt.imshow(images[i].numpy().astype("uint8"))
24         # 关闭坐标轴
25         plt.axis("off")
26 # 显示图形窗口
27 plt.show()

3、检查一下每个分组（训练 / 测试）中分别包含多少张图像

 1 # 导入所需的库
 2 import os
 3 # 训练集路径
 4 train_path = "C:/Users/horse-or-human/train/"
 5 # 统计训练集中马的图片数量
 6 print('训练集马的图片:', len(os.listdir(train_path + "horses")))
 7 # 统计训练集中人的图片数量
 8 print('训练集人的图片:', len(os.listdir(train_path + "humans")))
 9 # 验证集路径
10 valid_path = "C:/Users/horse-or-human/validation/"
11 # 统计验证集中马的图片数量
12 print('验证集马的图片:', len(os.listdir(valid_path + "horses")))
13 # 统计验证集中人的图片数量
14 print('验证集人的图片:', len(os.listdir(valid_path + "humans")))
15 # 测试集路径
16 test_path = "C:/Users/horse-or-human/test/"
17 # 统计测试集中图片的总数量
18 print('测试集图片:', len(os.listdir(test_path)))

4.搭建网络

 1 from keras import layers
 2 from keras import models
 3 
 4 # 创建一个Sequential模型
 5 model = models.Sequential()
 6 # 添加第一个卷积层，包括32个3x3的卷积核，激活函数为ReLU，输入图像尺寸为224x224x3
 7 model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(224, 224, 3)))
 8 # 添加最大池化层，使用2x2的窗口进行池化
 9 model.add(layers.MaxPooling2D((2, 2)))
10 # 添加第二个卷积层，包括64个3x3的卷积核，激活函数为ReLU
11 model.add(layers.Conv2D(64, (3, 3), activation='relu'))
12 # 再次添加最大池化层
13 model.add(layers.MaxPooling2D((2, 2)))
14 # 添加第三个卷积层，包括128个3x3的卷积核，激活函数为ReLU
15 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
16 # 再次添加最大池化层
17 model.add(layers.MaxPooling2D((2, 2)))
18 # 添加第四个卷积层，包括128个3x3的卷积核，激活函数为ReLU
19 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
20 # 最后添加一个全连接层前需要展平操作
21 model.add(layers.Flatten())
22 # 添加一个全连接层，包括512个神经元，激活函数为ReLU
23 model.add(layers.Dense(512, activation='relu'))
24 # 添加最后一个全连接层，包括一个神经元，激活函数为Sigmoid，用于二分类问题
25 model.add(layers.Dense(1, activation='sigmoid'))

5、查看特征图的维度随着每层变化

1 model.summary()

6.配置训练方法

1 model.compile(loss='binary_crossentropy',
2               optimizer=tf.keras.optimizers.RMSprop(lr=1e-4),
3               metrics=['acc'])

7.图像在输入神经网络之前进行数据处理，建立训练和验证数据,训练模型

 1 import tensorflow as tf
 2 from tensorflow.keras.preprocessing.image import ImageDataGenerator
 3 
 4 # 创建图像数据生成器，用于数据预处理和增强
 5 train_datagen = ImageDataGenerator(rescale=1./255)  # 训练集数据归一化
 6 test_datagen = ImageDataGenerator(rescale=1./255)   # 验证集数据归一化
 7 
 8 # 训练集和验证集的图片目录路径
 9 train_dir = 'C:/Users/horse-or-human/train'
10 validation_dir = 'C:/Users/horse-or-human/validation'
11 # 创建数据生成器，设置目标图像大小、批量大小和类别模式
12 batch_size = 20
13 train_generator = train_datagen.flow_from_directory(
14     train_dir,
15     target_size=(224, 224),
16     batch_size=batch_size,
17     class_mode='binary')  # 二分类问题
18 validation_generator = test_datagen.flow_from_directory(
19     validation_dir,
20     target_size=(224, 224),
21     batch_size=batch_size,
22     class_mode='binary')  # 二分类问题
23 # 计算训练集和验证集的样本数量
24 train_samples = len(train_generator.filenames)
25 validation_samples = len(validation_generator.filenames)
26 
27 # 计算每个训练周期的步数
28 steps_per_epoch = train_samples // batch_size
29 validation_steps = validation_samples // batch_size
30 # 训练模型，指定训练数据、训练步数、周期数、验证数据和验证步数
31 history = model.fit( 
32     train_generator,
33     steps_per_epoch=steps_per_epoch,
34     epochs=30,
35     validation_data=validation_generator,
36     validation_steps=validation_steps)
37 # 打印模型概要信息
38 model.summary()
39 # 保存训练好的模型
40 model.save('C:/Users/horse-or-human/result.h5')

 8.训练结果的精度和损失曲线图

 1 import matplotlib.pyplot as plt
 2 from matplotlib.font_manager import FontProperties
 3 
 4 # 指定中文字体的路径
 5 font_path = r"c:/windows/fonts/simsun.ttc"
 6 font = FontProperties(fname=font_path, size=14)
 7 
 8 # 绘制损失曲线和精度曲线图
 9 accuracy = history.history['acc']  # 训练集精度
10 loss = history.history['loss']  # 训练集损失
11 val_loss = history.history['val_loss']  # 验证集精度
12 val_accuracy = history.history['val_acc']  # 验证集损失
13 
14 plt.figure(figsize=(17, 7))
15 
16 # 训练集精度和验证集精度曲线图图
17 plt.subplot(2, 2, 1)
18 plt.plot(range(len(accuracy)), accuracy, 'bo', label='训练集精度')
19 plt.plot(range(len(val_accuracy)), val_accuracy, label='验证集精度')
20 plt.title('训练和验证精度', fontproperties=font)
21 plt.legend(loc='center right', prop=font)
22 
23 # 训练集损失和验证集损失图
24 plt.subplot(2, 2, 2)
25 plt.plot(range(len(loss)), loss, 'bo', label='训练损失')
26 plt.plot(range(len(val_loss)), val_loss, label='验证损失')
27 plt.title('训练和验证损失', fontproperties=font)
28 plt.legend(loc='center right', prop=font)
29 
30 # 训练集精度和损失散点图
31 plt.subplot(2, 2, 3)
32 plt.scatter(range(len(accuracy)), accuracy, label="训练集精度", color='b', s=25, marker="o")
33 plt.scatter(range(len(loss)), loss, label="训练损失", color='r', s=25, marker="o")
34 plt.title('训练精度和损失', fontproperties=font)
35 plt.legend(loc='center right', prop=font)
36 
37 # 验证集精度和损失散点图
38 plt.subplot(2, 2, 4)
39 plt.scatter(range(len(val_accuracy)), val_accuracy, label="验证集精度", color='b', s=25, marker="o")
40 plt.scatter(range(len(val_loss)), val_loss, label="验证损失", color='r', s=25, marker="o")
41 plt.title('验证精度和损失', fontproperties=font)
42 plt.legend(loc='center right', prop=font)
43 
44 plt.show()

 9.训练模型

1 # 训练模型
2 history = model.fit(
3     train_generator,
4     steps_per_epoch=steps_per_epoch,
5     epochs=20,
6     validation_data=validation_generator,
7     validation_steps=validation_steps)
8 model.summary()
9 model.save('C:/Users/horse-or-human/result.h5')

 10.测试

 1 import random
 2 import os
 3 import matplotlib.pyplot as plt
 4 from PIL import Image
 5 import numpy as np
 6 from keras.models import load_model
 7 from matplotlib.font_manager import FontProperties
 8 font = FontProperties(fname=r"c:/windows/fonts/simsun.ttc", size=14) # 指定中文字体的路径
 9 
10 # 指定目录
11 image_dir = 'C:/Users/horse-or-human/test/'
12 
13 # 获取目录中的所有图像文件
14 image_files = os.listdir(image_dir)
15 
16 # 随机选择一张图像
17 random_image = random.choice(image_files)
18 
19 # 加载模型
20 model = load_model('C:/Users/horse-or-human/result.h5')
21 
22 # 加载并处理图像
23 img_path = os.path.join(image_dir, random_image)
24 img = Image.open(img_path)
25 
26 # 去除 alpha 通道（如果有的话）
27 img = img.convert('RGB')
28 
29 # 调整大小和归一化
30 img = img.resize((224, 224), Image.BILINEAR)  # 调整大小为 (224, 224)
31 img_array = np.array(img)
32 img_array = img_array.astype('float32') / 255.0  # 归一化到0-1之间
33 img_array = img_array.reshape(1, 224, 224, 3)  # 添加批次维度，形状与模型期望相匹配
34 
35 # 使用模型进行预测
36 result = model.predict(img_array)
37 
38 # 显示图像和预测结果
39 plt.imshow(img_array[0])
40 plt.title(f"预测结果: {'人' if result > 0.5 else '马'}", fontproperties=font)
41 plt.show()

 总代码：

  1 import numpy as np
  2 import pandas as pd
  3 import os
  4 import tensorflow as tf
  5 import matplotlib.pyplot as plt
  6 from pathlib import Path
  7 from sklearn.model_selection import train_test_split
  8 from keras.models import Sequential
  9 from keras.layers import Activation
 10 from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
 11 from keras.applications.resnet import preprocess_input
 12 from keras.models import load_model
 13 from keras import optimizers
 14 # 导入必要的库
 15 import tensorflow as tf
 16 import matplotlib.pyplot as plt
 17 # 数据目录
 18 data_dir = "C:/Users/horse-or-human/validation"
 19 # 从目录中加载图像数据集
 20 train_ds = tf.keras.preprocessing.image_dataset_from_directory(
 21     data_dir,
 22     validation_split=0.1,  # 验证集占总数据的比例
 23     subset="training",  # 使用训练集子集
 24     seed=123,  # 随机种子，确保可重复性
 25     image_size=(224, 224),  # 图像大小
 26     batch_size=32  # 批量大小
 27 )
 28 # 创建一个大小为10x5的图形窗口
 29 plt.figure(figsize=(10, 5))
 30 # 从数据集中获取一批图像和标签
 31 for images, labels in train_ds.take(1):
 32     for i in range(8):
 33         # 创建2x4的子图中的一个
 34         ax = plt.subplot(2, 4, i + 1)
 35         # 显示图像
 36         plt.imshow(images[i].numpy().astype("uint8"))
 37         # 关闭坐标轴
 38         plt.axis("off")
 39 # 显示图形窗口
 40 plt.show()
 41 # 导入所需的库
 42 import os
 43 # 训练集路径
 44 train_path = "C:/Users/horse-or-human/train/"
 45 # 统计训练集中马的图片数量
 46 print('训练集马的图片:', len(os.listdir(train_path + "horses")))
 47 # 统计训练集中人的图片数量
 48 print('训练集人的图片:', len(os.listdir(train_path + "humans")))
 49 # 验证集路径
 50 valid_path = "C:/Users/horse-or-human/validation/"
 51 # 统计验证集中马的图片数量
 52 print('验证集马的图片:', len(os.listdir(valid_path + "horses")))
 53 # 统计验证集中人的图片数量
 54 print('验证集人的图片:', len(os.listdir(valid_path + "humans")))
 55 # 测试集路径
 56 test_path = "C:/Users/horse-or-human/test/"
 57 # 统计测试集中图片的总数量
 58 print('测试集图片:', len(os.listdir(test_path)))
 59 from keras import layers
 60 from keras import models
 61 
 62 # 创建一个Sequential模型
 63 model = models.Sequential()
 64 # 添加第一个卷积层，包括32个3x3的卷积核，激活函数为ReLU，输入图像尺寸为224x224x3
 65 model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(224, 224, 3)))
 66 # 添加最大池化层，使用2x2的窗口进行池化
 67 model.add(layers.MaxPooling2D((2, 2)))
 68 # 添加第二个卷积层，包括64个3x3的卷积核，激活函数为ReLU
 69 model.add(layers.Conv2D(64, (3, 3), activation='relu'))
 70 # 再次添加最大池化层
 71 model.add(layers.MaxPooling2D((2, 2)))
 72 # 添加第三个卷积层，包括128个3x3的卷积核，激活函数为ReLU
 73 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
 74 # 再次添加最大池化层
 75 model.add(layers.MaxPooling2D((2, 2)))
 76 # 添加第四个卷积层，包括128个3x3的卷积核，激活函数为ReLU
 77 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
 78 # 最后添加一个全连接层前需要展平操作
 79 model.add(layers.Flatten())
 80 # 添加一个全连接层，包括512个神经元，激活函数为ReLU
 81 model.add(layers.Dense(512, activation='relu'))
 82 # 添加最后一个全连接层，包括一个神经元，激活函数为Sigmoid，用于二分类问题
 83 model.add(layers.Dense(1, activation='sigmoid'))
 84 # 使用tensorflow.keras.optimizers中的RMSprop作为优化器
 85 # 损失函数为二分类交叉熵
 86 # 学习率为1e-4
 87 # 评估指标包括准确率（accuracy）
 88 model.compile(loss='binary_crossentropy',
 89               optimizer=tf.keras.optimizers.RMSprop(lr=1e-4),
 90               metrics=['acc'])
 91 import tensorflow as tf
 92 from tensorflow.keras.preprocessing.image import ImageDataGenerator
 93 
 94 # 创建图像数据生成器，用于数据预处理和增强
 95 train_datagen = ImageDataGenerator(rescale=1./255)  # 训练集数据归一化
 96 test_datagen = ImageDataGenerator(rescale=1./255)   # 验证集数据归一化
 97 
 98 # 训练集和验证集的图片目录路径
 99 train_dir = 'C:/Users/horse-or-human/train'
100 validation_dir = 'C:/Users/horse-or-human/validation'
101 # 创建数据生成器，设置目标图像大小、批量大小和类别模式
102 batch_size = 20
103 train_generator = train_datagen.flow_from_directory(
104     train_dir,
105     target_size=(224, 224),
106     batch_size=batch_size,
107     class_mode='binary')  # 二分类问题
108 validation_generator = test_datagen.flow_from_directory(
109     validation_dir,
110     target_size=(224, 224),
111     batch_size=batch_size,
112     class_mode='binary')  # 二分类问题
113 # 计算训练集和验证集的样本数量
114 train_samples = len(train_generator.filenames)
115 validation_samples = len(validation_generator.filenames)
116 
117 # 计算每个训练周期的步数
118 steps_per_epoch = train_samples // batch_size
119 validation_steps = validation_samples // batch_size
120 # 训练模型，指定训练数据、训练步数、周期数、验证数据和验证步数
121 history = model.fit( 
122     train_generator,
123     steps_per_epoch=steps_per_epoch,
124     epochs=30,
125     validation_data=validation_generator,
126     validation_steps=validation_steps)
127 # 打印模型概要信息
128 model.summary()
129 # 保存训练好的模型
130 model.save('C:/Users/horse-or-human/result.h5')
131 import matplotlib.pyplot as plt
132 from matplotlib.font_manager import FontProperties
133 
134 # 指定中文字体的路径
135 font_path = r"c:/windows/fonts/simsun.ttc"
136 font = FontProperties(fname=font_path, size=14)
137 
138 # 绘制损失曲线和精度曲线图
139 accuracy = history.history['acc']  # 训练集精度
140 loss = history.history['loss']  # 训练集损失
141 val_loss = history.history['val_loss']  # 验证集精度
142 val_accuracy = history.history['val_acc']  # 验证集损失
143 
144 plt.figure(figsize=(17, 7))
145 
146 # 训练集精度和验证集精度曲线图图
147 plt.subplot(2, 2, 1)
148 plt.plot(range(len(accuracy)), accuracy, 'bo', label='训练集精度')
149 plt.plot(range(len(val_accuracy)), val_accuracy, label='验证集精度')
150 plt.title('训练和验证精度', fontproperties=font)
151 plt.legend(loc='center right', prop=font)
152 
153 # 训练集损失和验证集损失图
154 plt.subplot(2, 2, 2)
155 plt.plot(range(len(loss)), loss, 'bo', label='训练损失')
156 plt.plot(range(len(val_loss)), val_loss, label='验证损失')
157 plt.title('训练和验证损失', fontproperties=font)
158 plt.legend(loc='center right', prop=font)
159 
160 # 训练集精度和损失散点图
161 plt.subplot(2, 2, 3)
162 plt.scatter(range(len(accuracy)), accuracy, label="训练集精度", color='b', s=25, marker="o")
163 plt.scatter(range(len(loss)), loss, label="训练损失", color='r', s=25, marker="o")
164 plt.title('训练精度和损失', fontproperties=font)
165 plt.legend(loc='center right', prop=font)
166 
167 # 验证集精度和损失散点图
168 plt.subplot(2, 2, 4)
169 plt.scatter(range(len(val_accuracy)), val_accuracy, label="验证集精度", color='b', s=25, marker="o")
170 plt.scatter(range(len(val_loss)), val_loss, label="验证损失", color='r', s=25, marker="o")
171 plt.title('验证精度和损失', fontproperties=font)
172 plt.legend(loc='center right', prop=font)
173 
174 plt.show()
175 # 训练模型
176 history = model.fit(
177     train_generator,
178     steps_per_epoch=steps_per_epoch,
179     epochs=20,
180     validation_data=validation_generator,
181     validation_steps=validation_steps)
182 model.summary()
183 model.save('C:/Users/horse-or-human/result.h5')
184 import random
185 import os
186 import matplotlib.pyplot as plt
187 from PIL import Image
188 import numpy as np
189 from keras.models import load_model
190 from matplotlib.font_manager import FontProperties
191 font = FontProperties(fname=r"c:/windows/fonts/simsun.ttc", size=14) # 指定中文字体的路径
192 
193 # 指定目录
194 image_dir = 'C:/Users/horse-or-human/test/'
195 
196 # 获取目录中的所有图像文件
197 image_files = os.listdir(image_dir)
198 
199 # 随机选择一张图像
200 random_image = random.choice(image_files)
201 
202 # 加载模型
203 model = load_model('C:/Users/horse-or-human/result.h5')
204 
205 # 加载并处理图像
206 img_path = os.path.join(image_dir, random_image)
207 img = Image.open(img_path)
208 
209 # 去除 alpha 通道（如果有的话）
210 img = img.convert('RGB')
211 
212 # 调整大小和归一化
213 img = img.resize((224, 224), Image.BILINEAR)  # 调整大小为 (224, 224)
214 img_array = np.array(img)
215 img_array = img_array.astype('float32') / 255.0  # 归一化到0-1之间
216 img_array = img_array.reshape(1, 224, 224, 3)  # 添加批次维度，形状与模型期望相匹配
217 
218 # 使用模型进行预测
219 result = model.predict(img_array)
220 
221 # 显示图像和预测结果
222 plt.imshow(img_array[0])
223 plt.title(f"预测结果: {'人' if result > 0.5 else '马'}", fontproperties=font)
224 plt.show()