机器学习——吸烟者识别

（一）选题背景

　　在现代文明社会中，人要面对各种各样的生活压力，为了舒解在现实生活中的紧张情绪,吸烟成为人们普遍选择的一种减轻压力的途径。但在公共场所吸烟是不文明的事情二手烟的危害远大于吸烟的危害，并且不存在所谓的“安全暴露”水平。只要在同一建筑内，即便安装空气净化或者通风设备等，都不能够消除二手烟的危害，通过此次机器识别来判断这个人是否是吸烟者。

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

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

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

　　参考来源：kaggle网站，猫狗大战

（三）机器学习的实现步骤

1.从kaggle网站中下载数据集，解压打开

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

 1 import os
 2 
 3 train_path="C:/Users/JC/Desktop/data/train/"
 4 print('not_smoking images:', len(os.listdir(train_path+"not_smoking")))
 5 print('smoking images:', len(os.listdir(train_path+"smoking")))
 6 
 7 valid_path="C:/Users/JC/Desktop/data/validation/"
 8 print('not_smoking images:', len(os.listdir(valid_path+"not_smoking")))
 9 print('smoking images:', len(os.listdir(valid_path+"smoking")))
10 
11 test_path="C:/Users/JC/Desktop/data/test/"
12 print('test images:', len(os.listdir(test_path)))

3.搭建卷积神经网络模型，输出特征图的维度

 1 from keras import layers
 2 from keras import models
 3 
 4 model = models.Sequential()
 5 
 6 # Output shape计算公式：(输入尺寸-卷积核尺寸/步长+1
 7 # 对CNN模型，Param的计算方法如下：
 8 # 卷积核长度*卷积核宽度*通道数+1）*卷积核个数
 9 # 输出图片尺寸：150-3+1=148*148  (输入尺寸-卷积核尺寸/步长+1
10 # 参数数量：32*3*3*3+32=896 ，32是卷积核个数
11 model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)))
12 
13 model.add(layers.MaxPooling2D((2, 2)))  # 输出图片尺寸：148/2=74*74
14 
15 # 输出图片尺寸：74-3+1=72*72，参数数量：64*3*3*32+64=18496
16 # 32是第1个卷积层的输出的通道数
17 model.add(layers.Conv2D(64, (3, 3), activation='relu'))
18 
19 model.add(layers.MaxPooling2D((2, 2)))  # 输出图片尺寸：72/2=36*36
20 
21 # Output Shape的输出为36
22 # 输出图片尺寸：36-3+1=34*34，参数数量：128*3*3*64+128=73856
23 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
24 model.add(layers.MaxPooling2D((2, 2)))  # 输出图片尺寸：34/2=17*17
25 
26 # 输出图片尺寸：17-3+1=15*15，参数数量：128*3*3*128+128=147584
27 model.add(layers.Conv2D(128, (3, 3), activation='relu'))
28 model.add(layers.MaxPooling2D((2, 2)))  # 输出图片尺寸：15/2=7*7
29 
30 #  多维转为一维：7*7*128=6272
31 model.add(layers.Flatten())
32 
33 #  参数数量：6272*512+512=3211776
34 model.add(layers.Dense(512, activation='relu'))
35 
36 #  参数数量：512*1+1=513
37 model.add(layers.Dense(1, activation='sigmoid'))
38 
39 model.summary()

4.遍历数据集中的文件，将路径数据和标签数据生成DataFrame

 1 from pathlib import Path
 2 import pandas as pd
 3 
 4 dir = Path('C:/Users/JC/Desktop/data/train/')
 5 
 6 # 用glob遍历在dir路径中所有jpg格式的文件，并将所有的文件名添加到filepaths列表中
 7 filepaths = list(dir.glob(r'**/*.jpg'))
 8 
 9 # 将文件中的分好的小文件名（种类名）分离并添加到labels的列表中
10 labels = list(map(lambda l: os.path.split(os.path.split(l)[0])[1], filepaths))
11 
12 # 将filepaths通过pandas转换为Series数据类型
13 filepaths = pd.Series(filepaths, name='FilePaths').astype(str)
14 
15 # 将labels通过pandas转换为Series数据类型
16 labels = pd.Series(labels, name='Labels').astype(str)
17 
18 # 将filepaths和Series两个Series的数据类型合成DataFrame数据类型
19 df = pd.merge(filepaths, labels, right_index=True, left_index=True)
20 df = df[df['Labels'].apply(lambda l: l[-2:] != 'GT')]
21 df = df.sample(frac=1).reset_index(drop=True)
22 #查看形成的DataFrame的数据
23 df

5.查看图像以及对应的标签

 1 #查看图像以及对应的标签
 2 fit, ax = plt.subplots(nrows=3, ncols=3, figsize=(10, 7))
 3 
 4 for i, a in enumerate(ax.flat):
 5     a.imshow(plt.imread(df.FilePaths[i]))
 6     a.set_title(df.Labels[i])
 7 
 8 plt.tight_layout()
 9 plt.show()
10 
11 #查看各个标签的图片张数
12 df['Labels'].value_counts(ascending=True)

6.对图像进行预处理

 1 # 归一化
 2 # 图像在输入神经网络之前进行数据处理，建立训练和验证数据
 3 from keras.preprocessing.image import ImageDataGenerator
 4 train_datagen = ImageDataGenerator(rescale = 1./255)
 5 test_datagen = ImageDataGenerator(rescale = 1./255)
 6 
 7 train_dir = 'C:/Users/JC/Desktop/data/train/'     # 指向训练集图片目录路径
 8 
 9 
10 train_generator = train_datagen.flow_from_directory(
11     train_dir,
12     target_size = (150,150),  #  输入训练图像尺寸
13     batch_size = 20,
14     class_mode = 'binary')  #
15 
16 validation_dir = 'C:/Users/JC/Desktop/data/validation/'  # 指向验证集图片目录路径
17 
18 validation_generator = test_datagen.flow_from_directory(
19     validation_dir,
20     target_size = (150,150),
21     batch_size = 20,
22     class_mode = 'binary')
23 
24 
25 for data_batch,labels_batch in train_generator:
26     print('data batch shape:',data_batch.shape)
27     print('data batch shape:',labels_batch.shape)
28     break  # 生成器不会停止，会循环生成这些批量，所以我们就循环生成一次批量

7.编译模型，对模型进行训练

 1 # 编译模型
 2 # RMSprop 优化器。因为网络最后一层是单一sigmoid单元，
 3 # 所以使用二元交叉熵作为损失函数
 4 from keras import optimizers
 5 
 6 
 7 model.compile(loss='binary_crossentropy',
 8               optimizer=optimizers.RMSprop(lr=1e-4),
 9               metrics=['acc'])
10 
11 # 训练模型10轮次
12 history = model.fit(
13                     train_generator,
14                     steps_per_epoch = 100,
15                     epochs = 20,
16                     validation_data = validation_generator,
17                     validation_steps = 50)

8.保存数据

1 #将训练过程产生的数据保存为h5文件
2 from keras.models import load_model
3 model.save('C:/Users/JC/Desktop/data/2103840259.h5')

9.绘制损失曲线和精度曲线图

 1 # 分别绘制训练过程中模型在训练数据和验证数据上的损失和精度
 2 import matplotlib.pyplot as plt
 3 loss = history.history['loss']
 4 val_loss = history.history['val_loss']
 5 epochs = range(1, len(loss) + 1)
 6 plt.plot(epochs, loss, 'bo', label = 'Training loss')
 7 plt.plot(epochs, val_loss, 'b', label = 'Validation loss')
 8 plt.title('Training And Validation Loss')
 9 plt.xlabel('Epochs')
10 plt.ylabel('Loss')
11 plt.legend()
12 plt.show()
13 
14 plt.clf()
15 
16 acc = history.history['acc']
17 val_acc = history.history['val_acc']
18 
19 plt.plot(epochs, acc, 'bo', label = 'Training acc')
20 plt.plot(epochs, val_acc, 'b', label = 'Validation acc')
21 plt.title('Training And Validation Accuracy')
22 plt.xlabel('Epochs')
23 plt.ylabel('Accuracy')
24 plt.legend()
25 plt.show()

10.从测试集中读取一条样本并显示

 1 #从测试集中读取一条样本
 2 img_path = "C:/Users/JC/Desktop/data/000023.jpg"
 3 
 4 from keras.preprocessing import image
 5 import numpy as np
 6 from keras.utils import image_utils
 7 
 8 img = image_utils.load_img(img_path, target_size=(150,150))
 9 img_tensor = image_utils.img_to_array(img)
10 img_tensor = np.expand_dims(img_tensor, axis=0)
11 img_tensor /= 255.
12 print(img_tensor.shape)
13 
14 # 显示样本
15 import matplotlib.pyplot as plt
16 plt.imshow(img_tensor[0])
17 plt.show()

11.建立模型，输入为原图像，输出为原模型的前8层的激活输出的特征图

 1 from keras import models
 2 
 3 layer_outputs = [layer.output for layer in model.layers[:8]]
 4 activation_model = models.Model(inputs=model.input, outputs=layer_outputs)
 5 #获得改样本的特征图
 6 activations = activation_model.predict(img_tensor)
 7 
 8 #显示第一层激活输出特的第一个滤波器的特征图
 9 import matplotlib.pyplot as plt
10 first_layer_activation = activations[0]
11 plt.matshow(first_layer_activation[0,:,:,1],  cmap="viridis")

12.显示前4层激活输出的全部特征图

 1 #存储层的名称
 2 layer_names = []
 3 for layer in model.layers[:4]:
 4     layer_names.append(layer.name)
 5 # 每行显示16个特征图
 6 images_pre_row = 16  #每行显示的特征图数
 7 # 循环8次显示8层的全部特征图
 8 for layer_name, layer_activation in zip(layer_names, activations):
 9     n_features = layer_activation.shape[-1] #保存当前层的特征图个数
10     size = layer_activation.shape[1]  #保存当前层特征图的宽高
11     n_col = n_features // images_pre_row #计算当前层显示多少行
12     #生成显示图像的矩阵
13     display_grid = np.zeros((size*n_col, images_pre_row*size))
14     #遍历将每个特张图的数据写入到显示图像的矩阵中
15     for col in range(n_col):
16         for row in range(images_pre_row):
17             #保存该张特征图的矩阵(size,size,1)
18             channel_image = layer_activation[0,:,:,col*images_pre_row+row]
19             #为使图像显示更鲜明，作一些特征处理
20             channel_image -= channel_image.mean()
21             channel_image /= channel_image.std()
22             channel_image *= 64
23             channel_image += 128 
24             #把该特征图矩阵中不在0-255的元素值修改至0-255
25             channel_image = np.clip(channel_image, 0, 255).astype("uint8")
26             #该特征图矩阵填充至显示图像的矩阵中
27             display_grid[col*size:(col+1)*size, row*size:(row+1)*size] = channel_image
28        
29     scale = 1./size
30     #设置该层显示图像的宽高
31     plt.figure(figsize=(scale*display_grid.shape[1],scale*display_grid.shape[0]))
32     plt.title(layer_name)
33     plt.grid(False)
34     #显示图像
35     plt.imshow(display_grid, aspect="auto", cmap="viridis")

13.取图像样本，改变其尺寸，并进行图片测试

 1 import matplotlib.pyplot as plt
 2 from PIL import Image
 3 import os.path
 4 
 5 def convertjpg(jpgfile,outdir,width=150,height=150): #将图片缩小到（150，150）的大小
 6     img=Image.open(jpgfile)
 7     try:
 8         new_img=img.resize((width,height),Image.BILINEAR)   
 9         new_img.save(os.path.join(outdir,os.path.basename(new_file)))
10     except Exception as e:
11         print(e)
12 
13 jpgfile= "C:/Users/JC/Desktop/data/000023.jpg"
14 new_file= "C:/Users/JC/Desktop/data/new_000023.jpg"
15 #图像大小改变到（150,150），文件名保存
16 convertjpg(jpgfile,r"C:/Users/JC/Desktop/data") 
17 img_scale = plt.imread('C:/Users/JC/Desktop/data/new_000023.jpg')
18 
19 plt.imshow(img_scale)        #显示改变图像大小后的图片确实变到了（150,150）大小
20 
21 # 导入h5模型
22 from keras.models import load_model
23 model = load_model('C:/Users/JC/Desktop/data/2103840259.h5')
24 
25 img_scale = img_scale.reshape(1,150,150,3).astype('float32')
26 img_scale = img_scale/255        # 归一化到0-1之间
27 
28 result = model.predict(img_scale)  # 取图片信息
29 # print(result)
30 if result>0.5:
31     print('是吸烟者的概率为：',result)
32 else:
33     print('不是吸烟者的概率为：',1-result)

 1 import matplotlib.pyplot as plt
 2 from PIL import Image
 3 import os.path
 4 
 5 def convertjpg(jpgfile,outdir,width=150,height=150): #将图片缩小到（150，150）的大小
 6     img=Image.open(jpgfile)
 7     try:
 8         new_img=img.resize((width,height),Image.BILINEAR)   
 9         new_img.save(os.path.join(outdir,os.path.basename(new_file)))
10     except Exception as e:
11         print(e)
12 
13 jpgfile= "C:/Users/JC/Desktop/data/gg0073.jpg"
14 new_file= "C:/Users/JC/Desktop/data/new_gg0073.jpg"
15 #图像大小改变到（150,150），文件名保存
16 convertjpg(jpgfile,r"C:/Users/JC/Desktop/data") 
17 img_scale = plt.imread('C:/Users/JC/Desktop/data/new_gg0073.jpg')
18 
19 plt.imshow(img_scale)        #显示改变图像大小后的图片确实变到了（150,150）大小
20 
21 # 导入h5模型
22 from keras.models import load_model
23 model = load_model('C:/Users/JC/Desktop/data/2103840259_smoke.h5')
24 
25 img_scale = img_scale.reshape(1,150,150,3).astype('float32')
26 img_scale = img_scale/255        # 归一化到0-1之间
27 
28 result = model.predict(img_scale)  # 取图片信息
29 # print(result)
30 if result>0.5:
31     print('是吸烟者的概率为：',result)
32 else:
33     print('不是吸烟者的概率为：',1-result)

全部代码附上：

  1 #检查一下每个分组（训练 / 测试）中分别包含多少张图像
  2 import os
  3 
  4 train_path="C:/Users/JC/Desktop/data/train/"
  5 print('not_smoking images:', len(os.listdir(train_path+"not_smoking")))
  6 print('smoking images:', len(os.listdir(train_path+"smoking")))
  7 
  8 valid_path="C:/Users/JC/Desktop/data/validation/"
  9 print('not_smoking images:', len(os.listdir(valid_path+"not_smoking")))
 10 print('smoking images:', len(os.listdir(valid_path+"smoking")))
 11 
 12 test_path="C:/Users/JC/Desktop/data/test/"
 13 print('test images:', len(os.listdir(test_path)))
 14 
 15 from keras import layers
 16 from keras import models
 17 
 18 # 搭建网络
 19 model = models.Sequential()
 20 # 第一个卷积层作为输入层，32个3*3卷积核，输入形状input_shape = (150,150,3)
 21 
 22 # 输出图片尺寸：150-3+1=148*148，参数数量：32*3*3*3+32=896
 23 model.add(layers.Conv2D(32,(3,3),activation = 'relu',input_shape = (150,150,3)))
 24 model.add(layers.MaxPooling2D((2,2)))  # 输出图片尺寸：148/2=74*74
 25 
 26 # 输出图片尺寸：74-3+1=72*72，参数数量：64*3*3*32+64=18496
 27 model.add(layers.Conv2D(64,(3,3),activation = 'relu'))
 28 model.add(layers.MaxPooling2D((2,2)))  # 输出图片尺寸：72/2=36*36
 29 
 30 # 输出图片尺寸：36-3+1=34*34，参数数量：128*3*3*64+128=73856
 31 model.add(layers.Conv2D(128,(3,3),activation = 'relu'))
 32 model.add(layers.MaxPooling2D((2,2)))  # 输出图片尺寸：34/2=17*17
 33 
 34 
 35 model.add(layers.Conv2D(128,(3,3),activation = 'relu'))
 36 model.add(layers.MaxPooling2D((2,2)))
 37 
 38 model.add(layers.Flatten())
 39 model.add(layers.Dense(512,activation = 'relu'))
 40 model.add(layers.Dense(1,activation = 'sigmoid'))  # sigmoid分类，输出是两类别
 41 
 42 # 看一下特征图的维度如何随着每层变化
 43 model.summary()
 44 
 45 from pathlib import Path
 46 import pandas as pd
 47 
 48 dir = Path('C:/Users/JC/Desktop/data/train/')
 49 
 50 # 用glob遍历在dir路径中所有jpg格式的文件，并将所有的文件名添加到filepaths列表中
 51 filepaths = list(dir.glob(r'**/*.jpg'))
 52 
 53 # 将文件中的分好的小文件名（种类名）分离并添加到labels的列表中
 54 labels = list(map(lambda l: os.path.split(os.path.split(l)[0])[1], filepaths))
 55 
 56 # 将filepaths通过pandas转换为Series数据类型
 57 filepaths = pd.Series(filepaths, name='FilePaths').astype(str)
 58 
 59 # 将labels通过pandas转换为Series数据类型
 60 labels = pd.Series(labels, name='Labels').astype(str)
 61 
 62 # 将filepaths和Series两个Series的数据类型合成DataFrame数据类型
 63 df = pd.merge(filepaths, labels, right_index=True, left_index=True)
 64 df = df[df['Labels'].apply(lambda l: l[-2:] != 'GT')]
 65 df = df.sample(frac=1).reset_index(drop=True)
 66 #查看形成的DataFrame的数据
 67 df
 68 
 69 #查看图像以及对应的标签
 70 fit, ax = plt.subplots(nrows=3, ncols=3, figsize=(10, 7))
 71 
 72 for i, a in enumerate(ax.flat):
 73     a.imshow(plt.imread(df.FilePaths[i]))
 74     a.set_title(df.Labels[i])
 75 
 76 plt.tight_layout()
 77 plt.show()
 78 
 79 #查看各个标签的图片张数
 80 df['Labels'].value_counts(ascending=True)
 81 
 82 
 83 # 归一化
 84 # 图像在输入神经网络之前进行数据处理，建立训练和验证数据
 85 from keras.preprocessing.image import ImageDataGenerator
 86 train_datagen = ImageDataGenerator(rescale = 1./255)
 87 test_datagen = ImageDataGenerator(rescale = 1./255)
 88 
 89 train_dir = 'C:/Users/JC/Desktop/data/train/'     # 指向训练集图片目录路径
 90 
 91 
 92 train_generator = train_datagen.flow_from_directory(
 93     train_dir,
 94     target_size = (150,150),  #  输入训练图像尺寸
 95     batch_size = 20,
 96     class_mode = 'binary')  #
 97 
 98 validation_dir = 'C:/Users/JC/Desktop/data/validation/'  # 指向验证集图片目录路径
 99 
100 validation_generator = test_datagen.flow_from_directory(
101     validation_dir,
102     target_size = (150,150),
103     batch_size = 20,
104     class_mode = 'binary')
105 
106 
107 for data_batch,labels_batch in train_generator:
108     print('data batch shape:',data_batch.shape)
109     print('data batch shape:',labels_batch.shape)
110     break  # 生成器不会停止，会循环生成这些批量，所以我们就循环生成一次批量
111 
112 # 编译模型
113 # RMSprop 优化器。因为网络最后一层是单一sigmoid单元，
114 # 所以使用二元交叉熵作为损失函数
115 from keras import optimizers
116 
117 
118 model.compile(loss='binary_crossentropy',
119               optimizer=optimizers.RMSprop(lr=1e-4),
120               metrics=['acc'])
121 # 训练模型20轮次
122 history = model.fit(
123                     train_generator,
124                     steps_per_epoch = 100,
125                     epochs = 20,
126                     validation_data = validation_generator,
127                     validation_steps = 50)
128 
129 #将训练过程产生的数据保存为h5文件
130 from keras.models import load_model
131 model.save('C:/Users/JC/Desktop/data/2103840259.h5')
132 
133 # 分别绘制训练过程中模型在训练数据和验证数据上的损失和精度
134 import matplotlib.pyplot as plt
135 loss = history.history['loss']
136 val_loss = history.history['val_loss']
137 epochs = range(1, len(loss) + 1)
138 plt.plot(epochs, loss, 'bo', label = 'Training loss')
139 plt.plot(epochs, val_loss, 'b', label = 'Validation loss')
140 plt.title('Training And Validation Loss')
141 plt.xlabel('Epochs')
142 plt.ylabel('Loss')
143 plt.legend()
144 plt.show()
145 
146 plt.clf()
147 
148 acc = history.history['acc']
149 val_acc = history.history['val_acc']
150 
151 plt.plot(epochs, acc, 'bo', label = 'Training acc')
152 plt.plot(epochs, val_acc, 'b', label = 'Validation acc')
153 plt.title('Training And Validation Accuracy')
154 plt.xlabel('Epochs')
155 plt.ylabel('Accuracy')
156 plt.legend()
157 plt.show()
158 
159 #从测试集中读取一条样本
160 img_path = "C:/Users/JC/Desktop/data/000023.jpg"
161 
162 from keras.preprocessing import image
163 import numpy as np
164 from keras.utils import image_utils
165 
166 img = image_utils.load_img(img_path, target_size=(150,150))
167 img_tensor = image_utils.img_to_array(img)
168 img_tensor = np.expand_dims(img_tensor, axis=0)
169 img_tensor /= 255.
170 print(img_tensor.shape)
171 
172 # 显示样本
173 import matplotlib.pyplot as plt
174 plt.imshow(img_tensor[0])
175 plt.show()
176 
177 #建立模型，输入为原图像，输出为原模型的前8层的激活输出的特征图
178 from keras import models
179 
180 layer_outputs = [layer.output for layer in model.layers[:8]]
181 activation_model = models.Model(inputs=model.input, outputs=layer_outputs)
182 #获得改样本的特征图
183 activations = activation_model.predict(img_tensor)
184 
185 #显示第一层激活输出特的第一个滤波器的特征图
186 import matplotlib.pyplot as plt
187 first_layer_activation = activations[0]
188 plt.matshow(first_layer_activation[0,:,:,1],  cmap="viridis")
189 
190 #存储层的名称
191 layer_names = []
192 for layer in model.layers[:4]:
193     layer_names.append(layer.name)
194 # 每行显示16个特征图
195 images_pre_row = 16  #每行显示的特征图数
196 # 循环8次显示8层的全部特征图
197 for layer_name, layer_activation in zip(layer_names, activations):
198     n_features = layer_activation.shape[-1] #保存当前层的特征图个数
199     size = layer_activation.shape[1]  #保存当前层特征图的宽高
200     n_col = n_features // images_pre_row #计算当前层显示多少行
201     #生成显示图像的矩阵
202     display_grid = np.zeros((size*n_col, images_pre_row*size))
203     #遍历将每个特张图的数据写入到显示图像的矩阵中
204     for col in range(n_col):
205         for row in range(images_pre_row):
206             #保存该张特征图的矩阵(size,size,1)
207             channel_image = layer_activation[0,:,:,col*images_pre_row+row]
208             #为使图像显示更鲜明，作一些特征处理
209             channel_image -= channel_image.mean()
210             channel_image /= channel_image.std()
211             channel_image *= 64
212             channel_image += 128 
213             #把该特征图矩阵中不在0-255的元素值修改至0-255
214             channel_image = np.clip(channel_image, 0, 255).astype("uint8")
215             #该特征图矩阵填充至显示图像的矩阵中
216             display_grid[col*size:(col+1)*size, row*size:(row+1)*size] = channel_image
217        
218     scale = 1./size
219     #设置该层显示图像的宽高
220     plt.figure(figsize=(scale*display_grid.shape[1],scale*display_grid.shape[0]))
221     plt.title(layer_name)
222     plt.grid(False)
223     #显示图像
224     plt.imshow(display_grid, aspect="auto", cmap="viridis")
225 
226     import matplotlib.pyplot as plt
227 from PIL import Image
228 import os.path
229 
230 def convertjpg(jpgfile,outdir,width=150,height=150): #将图片缩小到（150，150）的大小
231     img=Image.open(jpgfile)
232     try:
233         new_img=img.resize((width,height),Image.BILINEAR)   
234         new_img.save(os.path.join(outdir,os.path.basename(new_file)))
235     except Exception as e:
236         print(e)
237 
238 jpgfile= "C:/Users/JC/Desktop/data/000023.jpg"
239 new_file= "C:/Users/JC/Desktop/data/new_000023.jpg"
240 #图像大小改变到（150,150），文件名保存
241 convertjpg(jpgfile,r"C:/Users/JC/Desktop/data") 
242 img_scale = plt.imread('C:/Users/JC/Desktop/data/new_000023.jpg')
243 
244 plt.imshow(img_scale)        #显示改变图像大小后的图片确实变到了（150,150）大小
245 
246 # 导入h5模型
247 from keras.models import load_model
248 model = load_model('C:/Users/JC/Desktop/data/2103840259.h5')
249 
250 img_scale = img_scale.reshape(1,150,150,3).astype('float32')
251 img_scale = img_scale/255        # 归一化到0-1之间
252 
253 result = model.predict(img_scale)  # 取图片信息
254 # print(result)
255 if result>0.5:
256     print('是吸烟者的概率为：',result)
257 else:
258     print('不是吸烟者的概率为：',1-result)
259     
260 import matplotlib.pyplot as plt
261 from PIL import Image
262 import os.path
263 
264 def convertjpg(jpgfile,outdir,width=150,height=150): #将图片缩小到（150，150）的大小
265     img=Image.open(jpgfile)
266     try:
267         new_img=img.resize((width,height),Image.BILINEAR)   
268         new_img.save(os.path.join(outdir,os.path.basename(new_file)))
269     except Exception as e:
270         print(e)
271 
272 jpgfile= "C:/Users/JC/Desktop/data/gg0073.jpg"
273 new_file= "C:/Users/JC/Desktop/data/new_gg0073.jpg"
274 #图像大小改变到（150,150），文件名保存
275 convertjpg(jpgfile,r"C:/Users/JC/Desktop/data") 
276 img_scale = plt.imread('C:/Users/JC/Desktop/data/new_gg0073.jpg')
277 
278 plt.imshow(img_scale)        #显示改变图像大小后的图片确实变到了（150,150）大小
279 
280 # 导入h5模型
281 from keras.models import load_model
282 model = load_model('C:/Users/JC/Desktop/data/2103840259_smoke.h5')
283 
284 img_scale = img_scale.reshape(1,150,150,3).astype('float32')
285 img_scale = img_scale/255        # 归一化到0-1之间
286 
287 result = model.predict(img_scale)  # 取图片信息
288 # print(result)
289 if result>0.5:
290     print('是吸烟者的概率为：',result)
291 else:
292     print('不是吸烟者的概率为：',1-result)

(四）总结　　

　　从最终结果来看，本次设计的吸烟者识别，基本达到了设计初期的预期结果。经过这次课程设计，使我对机器学习有了进一步的了解，从收集数据、对数据进行预处理、自己构建网络模型、训练网络到最后的预测结果，加深了对图像识别过程的理解。在这过程中，也遇到了导入的库部分无法使用，版本不匹配等问题，最后也通过网上查找解决方法和同学帮助解决。