机器学习---水果和蔬菜的检测和识别

  1 #导入需要使用的库
  2 import matplotlib.pyplot as plt
  3 import numpy as np
  4 import pandas as pd
  5 from pathlib import Path
  6 import os
  7 import PIL
  8 import tensorflow as tf
  9 from tensorflow import keras
 10 from tensorflow.keras import layers
 11 from tensorflow.keras.models import Sequential
 12 
 13 # 创建一个包含训练和测试的文件路径列表
 14 train_dir = Path(r'C:\Users\chy\jzj\train')
 15 train_filepaths = list(train_dir.glob(r'**/*.jpg'))
 16 
 17 test_dir = Path(r'C:\Users\chy\jzj\test')
 18 test_filepaths = list(test_dir.glob(r'**/*.jpg'))
 19 
 20 val_dir = Path(r'C:\Users\chy\jzj\validation')
 21 val_filepaths = list(test_dir.glob(r'**/*.jpg'))
 22 
 23 def proc_img(filepath):
 24 #创建一个 DataFrame，其中包含图片的文件路径和标签
 25     
 26 # 从文件中提取标签
 27     labels = [str(filepath[i]).split("/")[-1] \
 28               for i in range(len(filepath))]
 29 # 将文件路径和标签转换为 Series 类型，并指定出列名
 30     filepath = pd.Series(filepath, name='Filepath').astype(str)
 31     labels = pd.Series(labels, name='Label')
 32 
 33     df = pd.concat([filepath, labels], axis=1)
 34 # 将文件路径和标签拼接成 DataFrame，并随机打乱排序和重置索引
 35     # Shuffle the DataFrame and reset index
 36     df = df.sample(frac=1).reset_index(drop = True)
 37     
 38     return df
 39 # 对训练、测试、验证集的文件路径进行处理，得到包含文件路径和标签的 DataFrame
 40 train_df = proc_img(train_filepaths)
 41 test_df = proc_img(test_filepaths)
 42 val_df = proc_img(val_filepaths)
 43 
 44 #TRAIN_DIR 表示训练集所在的文件夹路径
 45 #TEST_DIR 表示测试集所在的文件夹路径
 46 #VALID_DIR 表示验证集所在的文件夹路径
 47 TEST_DIR = r'C:\Users\chy\jzj\test'
 48 TRAIN_DIR =r'C:\Users\chy\jzj\train'
 49 VALID_DIR =r'C:\Users\chy\jzj\validation'
 50 
 51 #从指定目录 train_ds中加载图片数据集
 52 train_ds = tf.keras.preprocessing.image_dataset_from_directory(TRAIN_DIR,
 53                                                                seed=2509,
 54                                                                image_size=(img_height, img_width),
 55                                                                batch_size=batch_size)
 56 
 57 #实例化 ImageDataGenerator 类，进行数据增强操作
 58 train_generator = tf.keras.preprocessing.image.ImageDataGenerator(
 59     preprocessing_function=tf.keras.applications.mobilenet_v2.preprocess_input
 60 )
 61 
 62 test_generator = tf.keras.preprocessing.image.ImageDataGenerator(
 63     preprocessing_function=tf.keras.applications.mobilenet_v2.preprocess_input
 64 )
 65 
 66 #从文件夹中加载训练集
 67 train_images = train_generator.flow_from_dataframe(
 68     dataframe=train_df,
 69     x_col='Filepath',
 70     y_col='Label',
 71     target_size=(224, 224),
 72     color_mode='rgb',
 73     class_mode='categorical',
 74     batch_size=32,
 75     shuffle=True,
 76     seed=0,
 77     rotation_range=30,
 78     zoom_range=0.15,
 79     width_shift_range=0.2,
 80     height_shift_range=0.2,
 81     shear_range=0.15,
 82     horizontal_flip=True,
 83     fill_mode="nearest"
 84 )
 85 
 86 #从文件夹中加载训练集
 87 val_images = train_generator.flow_from_dataframe(
 88     dataframe=val_df,
 89     x_col='Filepath',
 90     y_col='Label',
 91     target_size=(224, 224),
 92     color_mode='rgb',
 93     class_mode='categorical',
 94     batch_size=32,
 95     shuffle=True,
 96     seed=0,
 97     rotation_range=30,
 98     zoom_range=0.15,
 99     width_shift_range=0.2,
100     height_shift_range=0.2,
101     shear_range=0.15,
102     horizontal_flip=True,
103     fill_mode="nearest"
104 )
105 
106 #从文件夹中加载训练集
107 test_images = test_generator.flow_from_dataframe(
108     dataframe=test_df,
109     x_col='Filepath',
110     y_col='Label',
111     target_size=(224, 224),
112     color_mode='rgb',
113     class_mode='categorical',
114     batch_size=32,
115     shuffle=False
116 )
117 
118 #通过 directory 参数来指定目录路径，从目录中加载训练集数据集
119 valid_ds = tf.keras.preprocessing.image_dataset_from_directory(VALID_DIR,
120                                                                seed=2509,
121                                                                image_size=(img_height, img_width),
122                                                                shuffle=False,
123                                                                batch_size=batch_size)
124 
125 test_ds = tf.keras.preprocessing.image_dataset_from_directory(TEST_DIR,
126                                                               seed=2509,
127                                                               image_size=(img_height, img_width),
128                                                               shuffle=False,
129                                                               batch_size=batch_size)
130 
131 import matplotlib.pyplot as plt
132 
133 #从训练集数据集中取出一个数据
134 plt.figure(figsize=(10, 10))
135 for images, labels in train_ds.take(1):
136     for i in range(9):
137         ax = plt.subplot(3, 3, i + 1)
138         plt.imshow(images[i].numpy().astype("uint8"))
139         plt.title(class_names[labels[i]])
140         plt.axis("off")
141 
142 #获取训练集数据集的类别名
143 class_names = train_ds.class_names
144 print(class_names)
145 
146 #加载 MobileNetV2 预训练模型
147 base_model = tf.keras.applications.MobileNetV2(input_shape=(224,224,3),
148                                                include_top=False,
149                                                weights='imagenet')
150 
151 base_model.trainable = False
152 
153 data_augmentation = tf.keras.Sequential([
154         tf.keras.layers.experimental.preprocessing.RandomFlip("horizontal"),
155         tf.keras.layers.experimental.preprocessing.RandomRotation(0.2),
156         tf.keras.layers.experimental.preprocessing.RandomZoom(0.2),
157 ])
158 
159 #定义模型结构
160 inputs = tf.keras.Input(shape=(224,224,3))
161 x = tf.keras.layers.experimental.preprocessing.Rescaling(1./255)(inputs)
162 x = data_augmentation(x)
163 x = base_model(x,training=False)
164 x = tf.keras.layers.GlobalAveragePooling2D()(x)#对卷积神经网络的输出进行全局平均池化操作
165 x = tf.keras.layers.Flatten()(x)
166 #包含1024个神经元的全连接层
167 x = tf.keras.layers.Dense(1024,activation='relu')(x)
168 #包含512个神经元的全连接层
169 x = tf.keras.layers.Dense(512,activation='relu')(x)
170 #添加输出层
171 x = tf.keras.layers.Dense(len(class_names),activation='softmax')(x)
172 
173 #使用 tf.keras.Model() 方法创建模型实例
174 model = tf.keras.Model(inputs=inputs, outputs=x, name="flower_vegetable_Detection_MobileNetV2")
175 #接下来的代码将进行编译模型的操作
176 model.compile(
177     loss = tf.keras.losses.SparseCategoricalCrossentropy(),
178     optimizer = tf.keras.optimizers.Adam(learning_rate=0.001),
179     metrics = ["accuracy"])
180 
181 #输出模型结构的摘要信息
182 model.summary()
183 
184 initial_epochs = 5
185 # 使用训练数据集对模型进行训练
186 history = model.fit(x=train_ds,
187                     epochs= initial_epochs,
188                     validation_data=valid_ds)
189 
190 # 从 history 中获取训练过程中记录的准确率、验证准确率、损失值和验证损失值等指标
191 acc = history.history['accuracy']
192 val_acc = history.history['val_accuracy']
193 
194 loss = history.history['loss']
195 val_loss = history.history['val_loss']
196 
197 # 使用 Matplotlib 库将训练准确率（Training Accuracy）、验证准确率（Validation Accuracy）、训练损失值（Training Loss）和验证损失值（Validation Loss）分别绘制成两张子图，展示训练和验证的变化趋势
198 plt.figure(figsize=(8, 8))
199 plt.subplot(2, 1, 1)
200 plt.plot(acc, label='Training Accuracy')
201 plt.plot(val_acc, label='Validation Accuracy')
202 plt.legend(loc='lower right')
203 plt.ylabel('Accuracy')
204 plt.ylim([min(plt.ylim()),1])
205 plt.title('Training and Validation Accuracy')
206 
207 plt.subplot(2, 1, 2)
208 plt.plot(loss, label='Training Loss')
209 plt.plot(val_loss, label='Validation Loss')
210 plt.legend(loc='upper right')
211 plt.ylabel('Cross Entropy')
212 plt.title('Training and Validation Loss')
213 plt.xlabel('epoch')
214 plt.show()
215 
216 base_model.trainable = True
217 # 编译模型
218 model.compile(
219     loss = tf.keras.losses.SparseCategoricalCrossentropy(),
220     optimizer = tf.keras.optimizers.Adam(1e-5),
221     metrics = ["accuracy"])
222 
223 fine_tune_epochs = 5
224 total_epochs =  initial_epochs + fine_tune_epochs
225 
226 #对模型进行调整
227 history_fine = model.fit(train_ds,
228                          epochs=total_epochs,
229                          initial_epoch=history.epoch[-1],
230                          validation_data=valid_ds)
231 
232 #将调整过后的模型训练过程中记录的准确率和损失值加入之前的列表中
233 acc += history_fine.history['accuracy']
234 val_acc += history_fine.history['val_accuracy']
235 
236 loss += history_fine.history['loss']
237 val_loss += history_fine.history['val_loss']
238 
239 # 绘制微调后的模型训练过程中准确率和损失值的变化曲线
240 
241 plt.figure(figsize=(8, 8))
242 plt.subplot(2, 1, 1)
243 plt.plot(acc, label='Training Accuracy')
244 plt.plot(val_acc, label='Validation Accuracy')
245 plt.ylim([0.0, 1])
246 plt.plot([initial_epochs-1,initial_epochs-1],
247           plt.ylim(), label='Start Fine Tuning')
248 plt.legend(loc='lower right')
249 plt.title('Training and Validation Accuracy')
250 
251 plt.subplot(2, 1, 2)
252 plt.plot(loss, label='Training Loss')
253 plt.plot(val_loss, label='Validation Loss')
254 plt.plot([initial_epochs-1,initial_epochs-1],
255          plt.ylim(), label='Start Fine Tuning')
256 plt.legend(loc='upper right')
257 plt.title('Training and Validation Loss')
258 plt.xlabel('epoch')
259 plt.show()
260 
261 # 对未用于训练的验证数据集进行预测
262 predictions = model.predict(valid_ds, verbose=1)
263 predictions.shape
264 np.sum(predictions[0])
265 predictions[0]
266 class_names[np.argmax(predictions[0])]
267 class_names[np.argmax(predictions[0])]
268 score = tf.nn.softmax(predictions[0])
269 score
270 np.save('class_names.npy',class_names)
271 model.save("flower_vegetable_detection_mobilenetv2.h5")
272 
273 # 对测试数据集进行评估，输出损失值和准确值
274 model.evaluate(test_ds)
275 
276   model = tf.keras.models.load_model(r'C:\Users\chy\jzj\flower_vegetable_detection_mobilenetv2.h5')
277 
278 import pickle
279 
280 #假设你已经训练好了一个识别模型，并且已经将其存储在一个名为 model 的变量中。现在，你想将这个模型保存到名为 model.pkl 的文件中
281 with open('model.pkl', 'wb') as f:
282     pickle.dump(model, f)