基于kears，对轿车、卡车和摩托车做机器学习，并对其进行数据增强提高准确率。

简介

本项目主要使用PYTHON Keras框架，对轿车、卡车、摩托车进行识别学习。

然后使用Keras 的图片数据增强，来增加识别的准确度。

由于的图片数量集数量有限，所以我们采用数据增强（data augmentation）技术来降低过拟合，并提高神经网络的识别精度。

 

数据集来源

对于数据集，我采用的是百度旗下飞浆学习里面的数据集。

如果有需要可以去这个网址进行学习。

https://aistudio.baidu.com/aistudio/datasetoverview

这个平台有非常多的数据集可以使用。

先对下载的数据集进行分类

我们先创建以下三个文件夹来作为不同的数据集

 

 

 然后在训练集（train）里面再分为三个小类。

分别为：轿车（car）摩托车（motorcycle）卡车（truck）

 

 

 

 这样我们的训练集都准备好了

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

 1 #检查一下每个分组（训练 / 测试）中分别包含多少张图像
 2 import os
 3 
 4 train_path="D:/data/train/"
 5 print('total training car images:', len(os.listdir(train_path+"car")))
 6 print('total training motorcycle images:', len(os.listdir(train_path+"motorcycle")))
 7 print('total training truck images:', len(os.listdir(train_path+"truck")))
 8 valid_path="D:/data/validation/"
 9 print('total validation car images:', len(os.listdir(valid_path+"car")))
10 print('total validation motorcycle images:', len(os.listdir(valid_path+"motorcycle")))
11 print('total validation truck images:', len(os.listdir(valid_path+"truck")))
12 
13 test_path="D:/data/test/"
14 print('total test images:', len(os.listdir(test_path)))

显示结果：

 

 

 修改训练集的图片名称

 1 #修改训练集的图片名称
 2 import os
 3 def rename(path,name):    
 4     filelist = os.listdir(path)
 5     total_num = len(filelist)
 6     print(total_num)
 7     i = 0
 8     for item in filelist:
 9         if item.endswith('.png'):
10             src = os.path.join(os.path.abspath(path), item)
11             dst = os.path.join(os.path.abspath(path), name+'.'+str(i) + '.png')
12             print(item,i)
13             try:
14                 
15                 os.rename(src, dst)
16                 print ("converting %s to %s ..." % (src, dst))
17                 i = i + 1
18             except:
19                 continue
20 
21 
22 rename('D:/data/train/car','car')
23 rename('D:/data/train/motorcycle','motorcycle')
24 rename('D:/data/train/truck','truck')

显示结果

 

 

 构建网络

在完成了数据集的清洗任务后，我们就需要搭建卷积神经网络了，我们使用Keras中的Sequential就可以完成网络构建的任务。

卷积神经网络结构由Conv2D层（使用relu函数激活）和MaxPooling2D层交替堆叠构成，这样既可以增大网络容量，也可以减少特征图的尺寸。

神经网络的最后两个层采用全连接层，分别采用relu和sigmoid激活。

在构建时我们先不采用数据增强，来查看训练的结果如何。

 1 #构建网络
 2 from tensorflow import keras
 3 import numpy as np
 4 from keras.preprocessing.image import ImageDataGenerator
 5 from keras import models
 6 from keras import layers
 7 import os
 8 from keras import optimizers
 9 from keras.utils import to_categorical
10 
11  
12 # 车辆数据预处理
13 train_dir = 'D:/data/train'
14 val_dir = 'D:/data/validation'
15  
16 # 不使用数据增强
17 train_datagen = ImageDataGenerator(rescale=1./255)
18 val_datagen = ImageDataGenerator(rescale=1./255)
19 
20 
21 # 使用迭代器生成图片张量
22 train_gen = train_datagen.flow_from_directory(train_dir, target_size=(224, 224), batch_size=20)
23 val_gen = train_datagen.flow_from_directory(val_dir, target_size=(224, 224), batch_size=20)
24  
25 model = models.Sequential()
26 
27 # 卷积采用3x3滑动卷积
28 model.add(layers.Conv2D(32, (3, 3), activation='relu',input_shape=(224, 224, 3)))
29 
30 
31 # 最大池化 采用 2x2
32 model.add(layers.MaxPool2D((2, 2)))
33 model.add(layers.Conv2D(64, (3, 3), activation='relu'))
34 model.add(layers.MaxPooling2D((2, 2)))
35 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
36 model.add(layers.MaxPooling2D((2, 2)))
37 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
38 model.add(layers.MaxPooling2D((2, 2)))
39 
40 # 展开成一维向量
41 model.add(layers.Flatten())
42 
43 # 使用dropout操作，降低过拟合，说白了就是随机丢掉一些神经元
44 model.add(layers.Dropout(0.5))
45 model.add(layers.Dense(512, activation='relu'))
46 
47 # 因为要分类3种车型图片，所以模型的最后一层采用3通道的输出对应3个分类
48 model.add(layers.Dense(3, activation='softmax'))

查看特征图的结构

1 # 显示模型的层级结构
2 model.summary()

显示结果

 

 

 从输出可以看出，神经网络在dense_1（Dense）层的参数总数达到了900多万。

模型编译

使用RNSprop优化器。因为网络的最后一层时单一sigmoid单元，所以使用二元交叉熵作为损失函数。

1 # 编译模型
2 model.compile(optimizer=optimizers.RMSprop(lr=1e-4), loss='binary_crossentropy', metrics=['acc'])

 训练模型

1 # 训练模型
2 history = model.fit_generator(train_gen, epochs=15, validation_data=val_gen)

显示结果

 

 

绘制损失曲线和精度曲线

 1 import matplotlib.pyplot as pl
 2 
 3 # 绘制训练精度损失曲线
 4 acc = history.history['acc']
 5 val_acc = history.history['val_acc']
 6 loss = history.history['loss']
 7 val_loss = history.history['val_loss']
 8  
 9 epochs = range(1, len(acc) + 1)
10 
11 plt.plot(epochs, acc, 'bo', label='Training acc')
12 plt.plot(epochs, val_acc, 'b', label='Validation acc')
13 plt.title('Training and validation accuracy')
14 plt.legend()
15 
16 plt.figure()
17 
18 plt.plot(epochs, loss, 'bo', label='Training loss')
19 plt.plot(epochs, val_loss, 'b', label='Validation loss')
20 plt.title('Training and validation loss')
21 plt.legend()
22 
23 plt.show()

显示结果

 

 

从这两个图像之中能看出过拟合的特征。训练精度随着时间线逐渐增加，知道接近100%，而验证精度则是在80-90%之间。主要还是因为我们的训练集图片比较少，所以导致了这个问题。

而我们可以采用数据增强的方法来增强我们的准确值。

使用数据增强

ImageDataGenerator参数

1 #定义ImageDataGenerator参数
2 datagen = ImageDataGenerator(
3     rotation_range = 40,
4     width_shift_range = 0.2,
5     height_shift_range = 0.2,
6     shear_range = 0.2,
7     zoom_range = 0.2,
8     horizontal_flip = True,
9     fill_mode = "nearest")

这些的参数的意义如下：

1、rotaion_range是角度值，表示图像随机旋转的范围。

2、width_shift和height_shift是图像在水平和垂直方向上平移的范围。
3、shear_range是随机错切变换的角度。

4、zoom_range是图像随机缩放的范围。

5、horizontal_flip是将图像随机做水平翻转。

6、fill_mode是用于填充新创建像素的方法。
随机增强一个图片

 1 # 利用ImageDataGenerator实现数据增强
 2 
 3 from keras.preprocessing.image import ImageDataGenerator
 4 from keras.preprocessing import image
 5 import os
 6 import matplotlib.pyplot as plt
 7 
 8 # 定义训练集目录
 9 train_car_dir = "D:/data/train/car"
10 
11 # 获得所有样本名称
12 car_fanmes = [os.path.join(train_car_dir,fname) for fname in os.listdir(train_car_dir)]
13 
14 
15 #定义ImageDataGenerator参数
16 datagen = ImageDataGenerator(
17     rotation_range = 40,
18     width_shift_range = 0.2,
19     height_shift_range = 0.2,
20     shear_range = 0.2,
21     zoom_range = 0.2,
22     horizontal_flip = True,
23     fill_mode = "nearest")
24 
25 
26 img_path = car_fanmes[14] #选一张图片观察
27 img = image.load_img(img_path, target_size=(150,150)) #读取图像并调整大小
28 x = image.img_to_array(img) #转换为形状（150，150，3）的numpy数组
29 x = x.reshape((1,) + x.shape) #将其形状改变为（1，150，150，3）
30 
31 i = 0
32 for batch in datagen.flow(x, batch_size=1): #循环是无限的，需要在某个时刻终止循环
33     plt.figure(i)
34     imgplot = plt.imshow(image.array_to_img(batch[0]))
35     i += 1
36     if i % 4 == 0:
37         break      
38 plt.show()

显示结果

 

 

 使用数据增强后重新构建模型

 1 #构建网络
 2 from tensorflow import keras
 3 import numpy as np
 4 from keras.preprocessing.image import ImageDataGenerator
 5 from keras import models
 6 from keras import layers
 7 import os
 8 from keras import optimizers
 9 from keras.utils import to_categorical
10 
11  
12 # 车辆数据预处理
13 train_dir = 'D:/data/train'
14 val_dir = 'D:/data/validation'
15  
16 # 使用数据增强
17 train_datagen = ImageDataGenerator(rescale = 1/255, 
18     rotation_range = 40, #角度值，0-180.表示图像随机旋转的角度范围
19     width_shift_range = 0.2, #平移比例，下同
20     height_shift_range = 0.2,
21     shear_range = 0.2, #随机错切变换角度
22     zoom_range = 0.2, #随即缩放比例
23     horizontal_flip = True, #随机将一半图像水平翻转
24     fill_mode='nearest') #填充新创建像素的方法
25                                    
26 # 不使用数据增强
27 val_datagen = ImageDataGenerator(rescale=1./255)
28 
29 
30 # 使用迭代器生成图片张量
31 train_gen = train_datagen.flow_from_directory(train_dir, target_size=(224, 224), batch_size=20)
32 val_gen = train_datagen.flow_from_directory(val_dir, target_size=(224, 224), batch_size=20)
33  
34 model = models.Sequential()
35 
36 # 卷积采用3x3滑动卷积
37 model.add(layers.Conv2D(32, (3, 3), activation='relu',input_shape=(224, 224, 3)))
38 
39 
40 # 最大池化 采用 2x2
41 model.add(layers.MaxPool2D((2, 2)))
42 model.add(layers.Conv2D(64, (3, 3), activation='relu'))
43 model.add(layers.MaxPooling2D((2, 2)))
44 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
45 model.add(layers.MaxPooling2D((2, 2)))
46 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
47 model.add(layers.MaxPooling2D((2, 2)))
48 
49 # 展开成一维向量
50 model.add(layers.Flatten())
51 
52 # 使用dropout操作，降低过拟合，说白了就是随机丢掉一些神经元
53 model.add(layers.Dropout(0.5))
54 model.add(layers.Dense(512, activation='relu'))
55 
56 # 因为要分类3种车型图片，所以模型的最后一层采用3通道的输出对应3个分类
57 model.add(layers.Dense(3, activation='softmax'))
58 # 编译模型
59 model.compile(optimizer=optimizers.RMSprop(lr=1e-4), loss='binary_crossentropy', metrics=['acc'])
60 
61 # 训练模型
62 # 由于我们对数据进行了增强，所以我们训练的轮次也要增加
63 history = model.fit_generator(train_gen, epochs=30, validation_data=val_gen)

显示结果

 

训练的数据展示

 1 import matplotlib.pyplot as plt
 2 
 3 # 绘制训练精度损失曲线
 4 acc = history.history['acc']
 5 val_acc = history.history['val_acc']
 6 loss = history.history['loss']
 7 val_loss = history.history['val_loss']
 8  
 9 epochs = range(1, len(acc) + 1)
10 
11 plt.plot(epochs, acc, 'bo', label='Training acc')
12 plt.plot(epochs, val_acc, 'b', label='Validation acc')
13 plt.title('Training and validation accuracy')
14 plt.legend()
15 
16 plt.figure()
17 
18 plt.plot(epochs, loss, 'bo', label='Training loss')
19 plt.plot(epochs, val_loss, 'b', label='Validation loss')
20 plt.title('Training and validation loss')
21 plt.legend()
22 
23 plt.show()

显示结果

 

 

 

通过图表可以看出，随着训练批次的增加，对应的评价参数基本是一直上升的，没有出现严重的过拟合现象，最后使用测试及验证，准确率大概在89%左右。

图像增强时只增加了一层dropout层，如果再增加过滤器层和调节其他参数，可以得到更高的精度，大概能在95%。

保存模型

1 #将训练过程产生的数据保存为h5文件
2 model.save('car.h5')

对模型进行检测

读取自定义图像并改变形状

 1  #读取用户自定义图像文件，改尺寸后保存
 2 
 3 import matplotlib.pyplot as plt
 4 from PIL import Image
 5 import os.path
 6 
 7 def convertjpg(jpgfile,outdir,width=224,height=224):#将图片缩小到（224，224）的大小
 8     img=Image.open(jpgfile)
 9     try:
10         new_img=img.resize((width,height),Image.BILINEAR)   
11         new_img.save(os.path.join(outdir,os.path.basename(jpgfile)))
12     except Exception as e:
13         print(e)
14         
15 jpgfile = 'D:/data/test/car.27.jpg'#读取原图像
16 convertjpg(jpgfile,"D:/data/")#图像大小改变到（224,224）
17 
18 img_scale = plt.imread('D:/data/car.27.jpg')
19 plt.imshow(img_scale)        #显示改变图像大小后的图片确实变到了（224,224）大小

显示结果

 

 实现识别

 1 ###导入模型car.h5
 2 
 3 from keras.models import load_model
 4 model = load_model('car.h5')
 5 
 6 img_scale = img_scale.reshape(-1,224,224,3).astype('float32')
 7 img_scale = img_scale/255        #归一化到0-1之间
 8 
 9 result = model.predict(img_scale) #取图片信息
10 print(result)

显示结果

 

再次识别

 1  #读取用户自定义图像文件，改尺寸后保存
 2 
 3 import matplotlib.pyplot as plt
 4 from PIL import Image
 5 import os.path
 6 
 7 def convertjpg(jpgfile,outdir,width=224,height=224):#将图片缩小到（224，224）的大小
 8     img=Image.open(jpgfile)
 9     try:
10         new_img=img.resize((width,height),Image.BILINEAR)   
11         new_img.save(os.path.join(outdir,os.path.basename(jpgfile)))
12     except Exception as e:
13         print(e)
14         
15 jpgfile = 'D:/data/test/truck.27.jpg'#读取原图像
16 convertjpg(jpgfile,"D:/data/")#图像大小改变到（224,224）
17 
18 img_scale = plt.imread('D:/data/truck.27.jpg')
19 plt.imshow(img_scale)        #显示改变图像大小后的图片确实变到了（224,224）大小

 

 识别结果

 1 ###导入模型car.h5
 2 
 3 from keras.models import load_model
 4 model = load_model('car.h5')
 5 
 6 img_scale = img_scale.reshape(-1,224,224,3).astype('float32')
 7 img_scale = img_scale/255        #归一化到0-1之间
 8 
 9 result = model.predict(img_scale) #取图片信息
10 print(result)

 

 结论

通过上面的两个列子可以得出。

我们自定义的图像对于轿车的识别率高达了84%，自定义的图像对于卡车的识别占有69%。说明我们对车辆的识别成功。

建议

1、后面我们可以增加数据集的数量，来提高一些准确度。

2、可以增加更多的汽车种类。

3、可以设计出图形化界面，这样就不用每一次都需要手动修改代码了。

 

完整代码

  1 #检查一下每个分组（训练 / 测试）中分别包含多少张图像
  2 import os
  3 
  4 train_path="D:/data/train/"
  5 print('total training car images:', len(os.listdir(train_path+"car")))
  6 print('total training motorcycle images:', len(os.listdir(train_path+"motorcycle")))
  7 print('total training truck images:', len(os.listdir(train_path+"truck")))
  8 valid_path="D:/data/validation/"
  9 print('total validation car images:', len(os.listdir(valid_path+"car")))
 10 print('total validation motorcycle images:', len(os.listdir(valid_path+"motorcycle")))
 11 print('total validation truck images:', len(os.listdir(valid_path+"truck")))
 12 
 13 test_path="D:/data/test/"
 14 print('total test images:', len(os.listdir(test_path)))
 15 #修改训练集的图片名称
 16 import os
 17 def rename(path,name):    
 18     filelist = os.listdir(path)
 19     total_num = len(filelist)
 20     print(total_num)
 21     i = 0
 22     for item in filelist:
 23         if item.endswith('.png'):
 24             src = os.path.join(os.path.abspath(path), item)
 25             dst = os.path.join(os.path.abspath(path), name+'.'+str(i) + '.png')
 26             print(item,i)
 27             try:
 28                 
 29                 os.rename(src, dst)
 30                 print ("converting %s to %s ..." % (src, dst))
 31                 i = i + 1
 32             except:
 33                 continue
 34 
 35 
 36 rename('D:/data/train/car','car')
 37 rename('D:/data/train/motorcycle','motorcycle')
 38 rename('D:/data/train/truck','truck')
 39 #构建网络
 40 from tensorflow import keras
 41 import numpy as np
 42 from keras.preprocessing.image import ImageDataGenerator
 43 from keras import models
 44 from keras import layers
 45 import os
 46 from keras import optimizers
 47 from keras.utils import to_categorical
 48 
 49  
 50 # 车辆数据预处理
 51 train_dir = 'D:/data/train'
 52 val_dir = 'D:/data/validation'
 53  
 54 # 不使用数据增强
 55 train_datagen = ImageDataGenerator(rescale=1./255)
 56 val_datagen = ImageDataGenerator(rescale=1./255)
 57 
 58 
 59 # 使用迭代器生成图片张量
 60 train_gen = train_datagen.flow_from_directory(train_dir, target_size=(224, 224), batch_size=20)
 61 val_gen = train_datagen.flow_from_directory(val_dir, target_size=(224, 224), batch_size=20)
 62  
 63 model = models.Sequential()
 64 
 65 # 卷积采用3x3滑动卷积
 66 model.add(layers.Conv2D(32, (3, 3), activation='relu',input_shape=(224, 224, 3)))
 67 
 68 
 69 # 最大池化 采用 2x2
 70 model.add(layers.MaxPool2D((2, 2)))
 71 model.add(layers.Conv2D(64, (3, 3), activation='relu'))
 72 model.add(layers.MaxPooling2D((2, 2)))
 73 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
 74 model.add(layers.MaxPooling2D((2, 2)))
 75 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
 76 model.add(layers.MaxPooling2D((2, 2)))
 77 
 78 # 展开成一维向量
 79 model.add(layers.Flatten())
 80 
 81 # 使用dropout操作，降低过拟合，说白了就是随机丢掉一些神经元
 82 # model.add(layers.Dropout(0.5))
 83 model.add(layers.Dense(512, activation='relu'))
 84 
 85 # 因为要分类3种车型图片，所以模型的最后一层采用3通道的输出对应3个分类
 86 model.add(layers.Dense(3, activation='softmax'))
 87 # 编译模型
 88 model.compile(optimizer=optimizers.RMSprop(lr=1e-4), loss='binary_crossentropy', metrics=['acc'])
 89 # 训练模型
 90 history = model.fit_generator(train_gen, epochs=15, validation_data=val_gen)
 91 import matplotlib.pyplot as plt
 92 
 93 # 绘制训练精度损失曲线
 94 acc = history.history['acc']
 95 val_acc = history.history['val_acc']
 96 loss = history.history['loss']
 97 val_loss = history.history['val_loss']
 98  
 99 epochs = range(1, len(acc) + 1)
100 
101 plt.plot(epochs, acc, 'bo', label='Training acc')
102 plt.plot(epochs, val_acc, 'b', label='Validation acc')
103 plt.title('Training and validation accuracy')
104 plt.legend()
105 
106 plt.figure()
107 
108 plt.plot(epochs, loss, 'bo', label='Training loss')
109 plt.plot(epochs, val_loss, 'b', label='Validation loss')
110 plt.title('Training and validation loss')
111 plt.legend()
112 
113 plt.show()# 利用ImageDataGenerator实现数据增强
114 
115 from keras.preprocessing.image import ImageDataGenerator
116 from keras.preprocessing import image
117 import os
118 import matplotlib.pyplot as plt
119 
120 # 定义训练集目录
121 train_car_dir = "D:/data/train/car"
122 
123 # 获得所有样本名称
124 car_fanmes = [os.path.join(train_car_dir,fname) for fname in os.listdir(train_car_dir)]
125 
126 
127 #定义ImageDataGenerator参数
128 datagen = ImageDataGenerator(
129     rotation_range = 40,
130     width_shift_range = 0.2,
131     height_shift_range = 0.2,
132     shear_range = 0.2,
133     zoom_range = 0.2,
134     horizontal_flip = True,
135     fill_mode = "nearest")
136 
137 
138 img_path = car_fanmes[14] #选一张图片观察
139 img = image.load_img(img_path, target_size=(150,150)) #读取图像并调整大小
140 x = image.img_to_array(img) #转换为形状（150，150，3）的numpy数组
141 x = x.reshape((1,) + x.shape) #将其形状改变为（1，150，150，3）
142 
143 i = 0
144 for batch in datagen.flow(x, batch_size=1): #循环是无限的，需要在某个时刻终止循环
145     plt.figure(i)
146     imgplot = plt.imshow(image.array_to_img(batch[0]))
147     i += 1
148     if i % 4 == 0:
149         break      
150 plt.show()
151 #构建网络
152 from tensorflow import keras
153 import numpy as np
154 from keras.preprocessing.image import ImageDataGenerator
155 from keras import models
156 from keras import layers
157 import os
158 from keras import optimizers
159 from keras.utils import to_categorical
160 
161  
162 # 车辆数据预处理
163 train_dir = 'D:/data/train'
164 val_dir = 'D:/data/validation'
165  
166 # 使用数据增强
167 train_datagen = ImageDataGenerator(rescale = 1/255, 
168     rotation_range = 40, #角度值，0-180.表示图像随机旋转的角度范围
169     width_shift_range = 0.2, #平移比例，下同
170     height_shift_range = 0.2,
171     shear_range = 0.2, #随机错切变换角度
172     zoom_range = 0.2, #随即缩放比例
173     horizontal_flip = True, #随机将一半图像水平翻转
174     fill_mode='nearest') #填充新创建像素的方法
175                                    
176 # 不使用数据增强
177 val_datagen = ImageDataGenerator(rescale=1./255)
178 
179 
180 # 使用迭代器生成图片张量
181 train_gen = train_datagen.flow_from_directory(train_dir, target_size=(224, 224), batch_size=20)
182 val_gen = train_datagen.flow_from_directory(val_dir, target_size=(224, 224), batch_size=20)
183  
184 model = models.Sequential()
185 
186 # 卷积采用3x3滑动卷积
187 model.add(layers.Conv2D(32, (3, 3), activation='relu',input_shape=(224, 224, 3)))
188 
189 
190 # 最大池化 采用 2x2
191 model.add(layers.MaxPool2D((2, 2)))
192 model.add(layers.Conv2D(64, (3, 3), activation='relu'))
193 model.add(layers.MaxPooling2D((2, 2)))
194 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
195 model.add(layers.MaxPooling2D((2, 2)))
196 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
197 model.add(layers.MaxPooling2D((2, 2)))
198 
199 # 展开成一维向量
200 model.add(layers.Flatten())
201 
202 # 使用dropout操作，降低过拟合，说白了就是随机丢掉一些神经元
203 model.add(layers.Dropout(0.5))
204 model.add(layers.Dense(512, activation='relu'))
205 
206 # 因为要分类3种车型图片，所以模型的最后一层采用3通道的输出对应3个分类
207 model.add(layers.Dense(3, activation='softmax'))
208 # 显示模型的层级结构
209 model.summary()
210 # 编译模型
211 model.compile(optimizer=optimizers.RMSprop(lr=1e-4), loss='binary_crossentropy', metrics=['acc'])
212 
213 # 训练模型
214 # 由于我们对数据进行了增强，所以我们训练的轮次也要增加
215 history = model.fit_generator(train_gen, epochs=30, validation_data=val_gen)
216 import matplotlib.pyplot as plt
217 
218 # 绘制训练精度损失曲线
219 acc = history.history['acc']
220 val_acc = history.history['val_acc']
221 loss = history.history['loss']
222 val_loss = history.history['val_loss']
223  
224 epochs = range(1, len(acc) + 1)
225 
226 plt.plot(epochs, acc, 'bo', label='Training acc')
227 plt.plot(epochs, val_acc, 'b', label='Validation acc')
228 plt.title('Training and validation accuracy')
229 plt.legend()
230 
231 plt.figure()
232 
233 plt.plot(epochs, loss, 'bo', label='Training loss')
234 plt.plot(epochs, val_loss, 'b', label='Validation loss')
235 plt.title('Training and validation loss')
236 plt.legend()
237 
238 plt.show()
239 #将训练过程产生的数据保存为h5文件
240 model.save('car.h5')
241  #读取用户自定义图像文件，改尺寸后保存
242 
243 import matplotlib.pyplot as plt
244 from PIL import Image
245 import os.path
246 
247 def convertjpg(jpgfile,outdir,width=224,height=224):#将图片缩小到（224，224）的大小
248     img=Image.open(jpgfile)
249     try:
250         new_img=img.resize((width,height),Image.BILINEAR)   
251         new_img.save(os.path.join(outdir,os.path.basename(jpgfile)))
252     except Exception as e:
253         print(e)
254         
255 jpgfile = 'D:/data/test/truck.27.jpg'#读取原图像
256 convertjpg(jpgfile,"D:/data/")#图像大小改变到（224,224）
257 
258 img_scale = plt.imread('D:/data/truck.27.jpg')
259 plt.imshow(img_scale)        #显示改变图像大小后的图片确实变到了（224,224）大小
260 ###导入模型car.h5
261 
262 from keras.models import load_model
263 model = load_model('car.h5')
264 
265 img_scale = img_scale.reshape(-1,224,224,3).astype('float32')
266 img_scale = img_scale/255        #归一化到0-1之间
267 
268 result = model.predict(img_scale) #取图片信息
269 print(result)

 

posted @ 2021-06-17 00:08  RNG-ken  阅读(377)  评论(0)  编辑  收藏  举报