JZTXT

机器学习——识别抽烟者与不抽烟者

发布时间 2023-06-05 21:48:09作者: li星空

选题背景

《中国吸烟危害健康报告（2012版）》的基础上，修订完成了《中国吸烟危害健康报告2020》，报告重点更新了吸烟和二手烟暴露的流行情况及危害健康的证据，特别是与呼吸系统疾病、恶性肿瘤、心脑血管疾病、糖尿病“四大慢病”的关系，同时新增了电子烟对健康的危害内容。所以面对抽烟问题，我们应该重视起来，机器学习技术可以通过对抽烟者与不抽烟者当时是否抽烟进行图像分析，进行识别，能快速判断是否抽烟。

步骤

1：下载数据集

数据集来源：数据集_CV数据集,计算机视觉数据集-极市开发者平台 (cvmart.net)

数据集

 2：建文件夹，拷贝数据

#导入需要的库
import os
import keras
import shutil
import numpy as np
import shutil
from keras import layers
#数据处理
#准备文件夹和文件
#创建文件路径
base_dir='./lml2103280114'

#train 800 nosmoking
#train 800 smoking
#test 200nosomking
#est 200 somking
train_dir=os.path.join(base_dir,'train')
train_dir_nosomking=os.path.join(train_dir,
'train_nosomking')
train_dir_somking=os.path.join(train_dir,
'train_somking')

test_dir=os.path.join(base_dir,'test')
test_dir_nosomking=os.path.join(test_dir,
'test_nosomking')
test_dir_somking=os.path.join(test_dir,
'test_somking')
#创建文件夹
if not os.mkdir(base_dir):
os.mkdir(train_dir)
os.mkdir(train_dir_nosomking)
os.mkdir(train_dir_somking)

os.mkdir(test_dir)
os.mkdir(test_dir_nosomking)
os.mkdir(test_dir_somking)
#拷贝文件
dc_dir='./数据集/train/train/'
#将命名为notsmoking_{}.jpg图片烤800张进入train_dir_nosomking文件夹中
fnames=[ 'notsmoking_{}.jpg'.format(i) for i in range(800)]
for fname in fnames:
original=os.path.join(dc_dir,
fname)
target=os_path.join(train_dir_nosomking,
fname)
shutil.copy(original,
taeget)
#将命名为notsmoking_{}.jpg图片烤200张进入test_dir_nosomking文件夹中
fnames=[ 'notsmoking_{}.jpg'.format(i) for i in range(200)]
for fname in fnames:
original=os.path.join(dc_dir,
fname)
target=os_path.join(test_dir_nosomking,
fname)
shutil.copy(original,
taeget)
#将命名为smoking_{}.jpg图片烤800张进入train_dir_somking文件夹中
fnames=[ 'smoking_{}.jpg'.format(i) for i in range(800)]
for fname in fnames:
original=os.path.join(dc_dir,
fname)
target=os_path.join(train_dir_somking,
fname)
shutil.copy(original,
taeget)
#将命名为smoking_{}.jpg图片烤200张进入train_dir_somking文件夹中
fnames=[ 'smoking_{}.jpg'.format(i) for i in range(200)]
for fname in fnames:
original=os.path.join(dc_dir,
fname)
target=os_path.join(test_dir_somking,
fname)
shutil.copy(original,
taeget)

 

建文件夹，拷贝数据

3：检测文件目录

#读取每个文件夹有多少张照片和类别
import os
train_path=r"C:\Users\admin\Desktop\lml2103280114\test"
print('total test new images:', len(os.listdir(train_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\test\test_somking"
print('total test test_somking images:', len(os.listdir(valid_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\test\test_nosomking"
print('total test test_nosomking images:', len(os.listdir(valid_path)))
train_path=r"C:\Users\admin\Desktop\lml2103280114\train"
print('total train new images:', len(os.listdir(train_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\train\train_somking"
print('total train train_somking images:', len(os.listdir(valid_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\train\train_nosomking"
print('total train train_nosomking images:', len(os.listdir(valid_path)))

 

读取照片数量

4：图片预处理

#图片预处理
#读取图片 解码 预处理 归一化
from keras.preprocessing.image import ImageDataGenerator
train_datagen=ImageDataGenerator(rescale=1/255 )
test_datagen=ImageDataGenerator(rescale=1/255)
train_dir=r'C:\Users\admin\Desktop\lml2103280114\train'

 

图片预处理
 

5：建立生成器

#建立生成器
train_generator=train_datagen.flow_from_directory(train_dir,
target_size=(200,200),
batch_size=20,
class_mode='binary')
test_dir=r'C:\Users\admin\Desktop\lml2103280114\test'
#建立生成器
test_generator=train_datagen.flow_from_directory(test_dir,
target_size=(200,200),
batch_size=20,
class_mode='binary')
for data_batch,labels_batch in train_generator:
print('data batch shape:',data_batch.shape)
print('data batch shape:',labels_batch.shape)
#生成器不会停止，会循环生成这些批 break 量，所以我们就循环生成一次批量
break

 

 

6：建立模型，预测

#建立模型
model=keras.Sequential()
from keras import layers
#卷积层1
model.add(layers.Conv2D(64,
(3,3),
activation='relu',
input_shape=(200,200,3)))
#卷积层2
model.add(layers.Conv2D(64,
(3,3),
activation='relu'))
#最大值池化层1
model.add(layers.MaxPooling2D())

model.add(layers.Dropout(0.25))
#卷积层3
model.add(layers.Conv2D(64,
(3,3),
activation='relu'))
#卷积层4
model.add(layers.Conv2D(64,
(3,3),
activation='relu'))
#最大值池化层1
model.add(layers.MaxPooling2D())

model.add(layers.Dropout(0.25))
model.add(layers.Conv2D(64,
(3,3),
activation='relu'))
model.add(layers.Conv2D(64,
(3,3),
activation='relu'))
#最大值池化层1
model.add(layers.MaxPooling2D())
model.add(layers.Dropout(0.25))

model.add(layers.Flatten())
#全连接层1
model.add(layers.Dense(256,
activation='relu'))
model.add(layers.Dense(1,
activation='sigmoid'))
import tensorflow as tf
model.compile(optimizer=tf.keras.optimizers.Adam(lr=0.0001),
loss='binary_crossentropy',
metrics='acc')

 

 

7：训练模型

#训练模型
result=model.fit_generator(train_generator,
epochs=20,
steps_per_epoch=30,
validation_data=test_generator,
validation_steps=50
)
#输出训练过程的历史数据
result.history
model.summary()

 

 

 

 8：#将训练过程产生的数据保存为h5文件

 

8：#将训练过程产生的数据保存为h5文件

from keras.models import load_model
model.save(r'C:\Users\admin\Desktop\lml2103280114\2103280114.h5')
#如何打开.h5文件
from keras.models import load_model
from keras import layers
from keras import models

model=load_model(r'C:\Users\admin\Desktop\lml2103280114\2103280114.h5')

 

 9：绘制图像

#绘制训练过程中精度曲线
import matplotlib.pyplot as plt
acc = result.history['acc']
epochs = range(1,
len(acc) + 1)

plt.plot(epochs,
acc,
'bo',
label='Training acc')

plt.title(' accuracy')
plt.legend()
#绘制训练过程中的损失曲线和精度曲线
import matplotlib.pyplot as plt
loss =result.history['loss']
epochs = range(1,
len(acc) + 1)
plt.plot(epochs,
loss,
'b',
label='loss')
plt.title('loss')
plt.legend()
#绘制训练过程中的损失曲线和精度曲线
import matplotlib.pyplot as plt

acc = result.history['acc']

loss =result.history['loss']


epochs = range(1,
len(acc) + 1)

plt.plot(epochs,
acc,
'bo',
label='Training acc')
plt.plot(epochs,
loss,
'b',
label='loss')
plt.title('Training and validation accuracy')
plt.legend()

 

 

 

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

from keras.utils import image_utils
#C:\Users\admin\Desktop\lml2103280114\train\train_somking
img_path = r"C:\Users\admin\Desktop\lml2103280114\train\train_somking\smoking_0001.jpg"

#img_path = r"C:\Users\admin\Desktop\cats_and_dogs_small\train\dogs\dog.168.jpg"

from keras.preprocessing import image
import numpy as np

img = image_utils.load_img(img_path, target_size=(150,150))
img_tensor = image_utils.img_to_array(img)
img_tensor = np.expand_dims(img_tensor, axis=0)
img_tensor /= 255.
print(img_tensor.shape)
#显示样本
import matplotlib.pyplot as plt
plt.imshow(img_tensor[0])
plt.show()

 

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

from keras import models
layer_outputs = [layer.output for layer in model.layers[:8]]
activation_model = models.Model(inputs=model.input, outputs=layer_outputs)
#获得改样本的特征图
activations = activation_model.predict(img_tensor)

12：#显示第一层激活输出特的第一个滤波器的特征图

import matplotlib.pyplot as plt
first_layer_activation = activations[0]
plt.matshow(first_layer_activation[0,:,:,1], cmap="viridis")

 

 13：特征分析

#存储层的名称
layer_names = []
for layer in model.layers[:4]:
layer_names.append(layer.name)
# 每行显示16个特征图
images_pre_row = 16 #每行显示的特征图数
# 循环8次显示8层的全部特征图
for layer_name, layer_activation in zip(layer_names, activations):
n_features = layer_activation.shape[-1] #保存当前层的特征图个数
size = layer_activation.shape[1] #保存当前层特征图的宽高
n_col = n_features // images_pre_row #计算当前层显示多少行
#生成显示图像的矩阵
display_grid = np.zeros((size*n_col, images_pre_row*size))
#遍历将每个特张图的数据写入到显示图像的矩阵中
for col in range(n_col):
for row in range(images_pre_row):
#保存该张特征图的矩阵(size,size,1)
channel_image = layer_activation[0,:,:,col*images_pre_row+row]
#为使图像显示更鲜明，作一些特征处理
channel_image -= channel_image.mean()
channel_image /= channel_image.std()
channel_image *= 64
channel_image += 128
#把该特征图矩阵中不在0-255的元素值修改至0-255
channel_image = np.clip(channel_image, 0, 255).astype("uint8")
#该特征图矩阵填充至显示图像的矩阵中
display_grid[col*size:(col+1)*size, row*size:(row+1)*size] = channel_image


scale = 1./size
#设置该层显示图像的宽高
plt.figure(figsize=(scale*display_grid.shape[1],scale*display_grid.shape[0]))
plt.title(layer_name)
plt.grid(False)
#显示图像
plt.imshow(display_grid, aspect="auto", cmap="viridis")

 

 

 14：预测

from keras.models import load_model
model = load_model(r'C:\Users\admin\Desktop\lml2103280114\2103280114.h5')
#model.summary()
img_scale = plt.imread( 'C:/Users/admin/Desktop/notsmoking_0001.JPG')
img_scale = img_scale.reshape(1,150,150,3).astype('float32')
img_scale = img_scale/255 #归一化到0-1之间

result = model.predict(img_scale) #取图片信息

#print(result)
img_scale = plt.imread('C:/Users/admin/Desktop/notsmoking_0001.JPG')

plt.imshow(img_scale) #显示图片

if result>0.5:
print('该图片是抽烟者的概率为：',result)
else:
print('该图片是不抽烟者的概率为：',1-result)

 

 完整代码

#完整代码
#导入需要的库
import os
import keras
import shutil
import numpy as np
import shutil
from keras import layers
#数据处理
#准备文件夹和文件
#创建文件路径
base_dir='./lml2103280114'

#train 800 nosmoking
#train 800 smoking
#test 200nosomking
#est 200 somking
train_dir=os.path.join(base_dir,'train')
train_dir_nosomking=os.path.join(train_dir,
'train_nosomking')
train_dir_somking=os.path.join(train_dir,
'train_somking')

test_dir=os.path.join(base_dir,'test')
test_dir_nosomking=os.path.join(test_dir,
'test_nosomking')
test_dir_somking=os.path.join(test_dir,
'test_somking')
#创建文件夹
if not os.mkdir(base_dir):
os.mkdir(train_dir)
os.mkdir(train_dir_nosomking)
os.mkdir(train_dir_somking)

os.mkdir(test_dir)
os.mkdir(test_dir_nosomking)
os.mkdir(test_dir_somking)
#拷贝文件
dc_dir='./数据集/train/train/'
#将命名为notsmoking_{}.jpg图片烤800张进入train_dir_nosomking文件夹中
fnames=[ 'notsmoking_{}.jpg'.format(i) for i in range(800)]
for fname in fnames:
original=os.path.join(dc_dir,
fname)
target=os_path.join(train_dir_nosomking,
fname)
shutil.copy(original,
taeget)
#将命名为notsmoking_{}.jpg图片烤200张进入test_dir_nosomking文件夹中
fnames=[ 'notsmoking_{}.jpg'.format(i) for i in range(200)]
for fname in fnames:
original=os.path.join(dc_dir,
fname)
target=os_path.join(test_dir_nosomking,
fname)
shutil.copy(original,
taeget)
#将命名为smoking_{}.jpg图片烤800张进入train_dir_somking文件夹中
fnames=[ 'smoking_{}.jpg'.format(i) for i in range(800)]
for fname in fnames:
original=os.path.join(dc_dir,
fname)
target=os_path.join(train_dir_somking,
fname)
shutil.copy(original,
taeget)
#将命名为smoking_{}.jpg图片烤200张进入train_dir_somking文件夹中
fnames=[ 'smoking_{}.jpg'.format(i) for i in range(200)]
for fname in fnames:
original=os.path.join(dc_dir,
fname)
target=os_path.join(test_dir_somking,
fname)
shutil.copy(original,
taeget)
#读取每个文件夹有多少张照片和类别
import os
train_path=r"C:\Users\admin\Desktop\lml2103280114\test"
print('total test new images:', len(os.listdir(train_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\test\test_somking"
print('total test test_somking images:', len(os.listdir(valid_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\test\test_nosomking"
print('total test test_nosomking images:', len(os.listdir(valid_path)))
train_path=r"C:\Users\admin\Desktop\lml2103280114\train"
print('total train new images:', len(os.listdir(train_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\train\train_somking"
print('total train train_somking images:', len(os.listdir(valid_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\train\train_nosomking"
print('total train train_nosomking images:', len(os.listdir(valid_path)))
#图片预处理
#读取图片
#图片解码
#图片预处理
#图片归一化
from keras.preprocessing.image import ImageDataGenerator
train_datagen=ImageDataGenerator(rescale=1/255 )
test_datagen=ImageDataGenerator(rescale=1/255)
#建立生成器
train_dir=r'C:\Users\admin\Desktop\lml2103280114\train'

train_generator=train_datagen.flow_from_directory(train_dir,
target_size=(200,200),
batch_size=20,
class_mode='binary')
test_dir=r'C:\Users\admin\Desktop\lml2103280114\test'
#建立生成器
test_generator=train_datagen.flow_from_directory(test_dir,
target_size=(200,200),
batch_size=20,
class_mode='binary')
#建立模型
model=keras.Sequential()
from keras import layers
#卷积层1
model.add(layers.Conv2D(64,
(3,3),
activation='relu',
input_shape=(200,200,3)))
#卷积层2
model.add(layers.Conv2D(64,
(3,3),
activation='relu'))
#最大值池化层1
model.add(layers.MaxPooling2D())

model.add(layers.Dropout(0.25))
#卷积层3
model.add(layers.Conv2D(64,
(3,3),
activation='relu'))
#卷积层4
model.add(layers.Conv2D(64,
(3,3),
activation='relu'))
#最大值池化层1
model.add(layers.MaxPooling2D())

model.add(layers.Dropout(0.25))
model.add(layers.Conv2D(64,
(3,3),
activation='relu'))
model.add(layers.Conv2D(64,
(3,3),
activation='relu'))
#最大值池化层1
model.add(layers.MaxPooling2D())
model.add(layers.Dropout(0.25))

model.add(layers.Flatten())
#全连接层1
model.add(layers.Dense(256,
activation='relu'))
model.add(layers.Dense(1,
activation='sigmoid'))
import tensorflow as tf
model.compile(optimizer=tf.keras.optimizers.Adam(lr=0.0001),
loss='binary_crossentropy',
metrics='acc')
#训练模型
result=model.fit_generator(train_generator,
epochs=20,
steps_per_epoch=30,
validation_data=test_generator,
validation_steps=50
)
#输出训练过程的历史数据
result.history
model.summary()
#将训练过程产生的数据保存为h5文件
from keras.models import load_model
model.save(r'C:\Users\admin\Desktop\lml2103280114\2103280114.h5')
#如何打开.h5文件
from keras.models import load_model
from keras import layers
from keras import models
model=load_model(r'C:\Users\admin\Desktop\lml2103280114\2103280114.h5')
#绘制训练过程中精度曲线
import matplotlib.pyplot as plt
acc = result.history['acc']
epochs = range(1,
len(acc) + 1)
plt.plot(epochs,
acc,
'bo',
label='Training acc')
plt.title(' accuracy')
plt.legend()
#绘制训练过程中的损失曲线和精度曲线
import matplotlib.pyplot as plt
loss =result.history['loss']
epochs = range(1,
len(acc) + 1)
plt.plot(epochs,
loss,
'b',
label='loss')
plt.title('loss')
plt.legend()
#绘制训练过程中的损失曲线和精度曲线
import matplotlib.pyplot as plt
acc = result.history['acc']
loss =result.history['loss']
epochs = range(1,
len(acc) + 1)
plt.plot(epochs,
acc,
'bo',
label='Training acc')
plt.plot(epochs,
loss,
'b',
label='loss')
plt.title('Training and validation accuracy')
plt.legend()
# 从测试集中读取一条样本
from keras.utils import image_utils
#C:\Users\admin\Desktop\lml2103280114\train\train_somking
img_path = r"C:\Users\admin\Desktop\lml2103280114\train\train_somking\smoking_0001.jpg"

#img_path = r"C:\Users\admin\Desktop\cats_and_dogs_small\train\dogs\dog.168.jpg"

from keras.preprocessing import image
import numpy as np

img = image_utils.load_img(img_path, target_size=(150,150))
img_tensor = image_utils.img_to_array(img)
img_tensor = np.expand_dims(img_tensor, axis=0)
img_tensor /= 255.
print(img_tensor.shape)
#显示样本
import matplotlib.pyplot as plt
plt.imshow(img_tensor[0])
plt.show()
#显示第一层激活输出特的第一个滤波器的特征图
import matplotlib.pyplot as plt
first_layer_activation = activations[0]
plt.matshow(first_layer_activation[0,:,:,1], cmap="viridis")
#存储层的名称
layer_names = []
for layer in model.layers[:4]:
layer_names.append(layer.name)
# 每行显示16个特征图
images_pre_row = 16 #每行显示的特征图数
# 循环8次显示8层的全部特征图
for layer_name, layer_activation in zip(layer_names, activations):
n_features = layer_activation.shape[-1] #保存当前层的特征图个数
size = layer_activation.shape[1] #保存当前层特征图的宽高
n_col = n_features // images_pre_row #计算当前层显示多少行
#生成显示图像的矩阵
display_grid = np.zeros((size*n_col, images_pre_row*size))
#遍历将每个特张图的数据写入到显示图像的矩阵中
for col in range(n_col):
for row in range(images_pre_row):
#保存该张特征图的矩阵(size,size,1)
channel_image = layer_activation[0,:,:,col*images_pre_row+row]
#为使图像显示更鲜明，作一些特征处理
channel_image -= channel_image.mean()
channel_image /= channel_image.std()
channel_image *= 64
channel_image += 128
#把该特征图矩阵中不在0-255的元素值修改至0-255
channel_image = np.clip(channel_image, 0, 255).astype("uint8")
#该特征图矩阵填充至显示图像的矩阵中
display_grid[col*size:(col+1)*size, row*size:(row+1)*size] = channel_image


scale = 1./size
#设置该层显示图像的宽高
plt.figure(figsize=(scale*display_grid.shape[1],scale*display_grid.shape[0]))
plt.title(layer_name)
plt.grid(False)
#显示图像
plt.imshow(display_grid, aspect="auto", cmap="viridis")
#预测
###导入模型
from keras.models import load_model
model = load_model(r'C:\Users\admin\Desktop\lml2103280114\2103280114.h5')
#model.summary()
img_scale = plt.imread( 'C:/Users/admin/Desktop/notsmoking_0001.JPG')
img_scale = img_scale.reshape(1,150,150,3).astype('float32')
img_scale = img_scale/255 #归一化到0-1之间
result = model.predict(img_scale) #取图片信息
#print(result)
img_scale = plt.imread('C:/Users/admin/Desktop/notsmoking_0001.JPG')
plt.imshow(img_scale) #显示图片
if result>0.5:
print('该图片是抽烟者的概率为：',result)
else:
print('该图片是不抽烟者的概率为：',1-result)
#导入需要的库
import os
import keras
import shutil
import numpy as np
import shutil
from keras import layers
#数据处理
#准备文件夹和文件
#创建文件路径
base_dir='./lml2103280114'
#train 800 nosmoking 
#train 800 smoking 
#test 200nosomking 
#est 200 somking
train_dir=os.path.join(base_dir,'train')
train_dir_nosomking=os.path.join(train_dir,
                                 'train_nosomking')
train_dir_somking=os.path.join(train_dir,
                               'train_somking')
test_dir=os.path.join(base_dir,'test')
test_dir_nosomking=os.path.join(test_dir,
                                'test_nosomking')
test_dir_somking=os.path.join(test_dir,
                              'test_somking')
#创建文件夹
if not os.mkdir(base_dir):
    os.mkdir(train_dir)
os.mkdir(train_dir_nosomking)
os.mkdir(train_dir_somking)
os.mkdir(test_dir)
os.mkdir(test_dir_nosomking)
os.mkdir(test_dir_somking)
#拷贝文件
dc_dir='./数据集/train/train/'
#将命名为notsmoking_{}.jpg图片烤800张进入train_dir_nosomking文件夹中
fnames=[ 'notsmoking_{}.jpg'.format(i) for i in range(800)]
for fname in fnames:
    original=os.path.join(dc_dir, fname)
    target=os_path.join(train_dir_nosomking,fname)
    shutil.copy(original,
                taeget)
    #将命名为notsmoking_{}.jpg图片烤200张进入test_dir_nosomking文件夹中
fnames=[ 'notsmoking_{}.jpg'.format(i) for i in range(200)]
for fname in fnames:
    original=os.path.join(dc_dir,
                          fname)
    target=os_path.join(test_dir_nosomking,
                        fname)
    shutil.copy(original,
                taeget)
    #将命名为smoking_{}.jpg图片烤800张进入train_dir_somking文件夹中
    fnames=[ 'smoking_{}.jpg'.format(i) for i in range(800)]
for fname in fnames:
    original=os.path.join(dc_dir,
                          fname)
    target=os_path.join(train_dir_somking,
                        fname)
    shutil.copy(original,
                taeget)
    #将命名为smoking_{}.jpg图片烤200张进入train_dir_somking文件夹中
    fnames=[ 'smoking_{}.jpg'.format(i) for i in range(200)]
for fname in fnames:
    original=os.path.join(dc_dir,
                          fname)
    target=os_path.join(test_dir_somking,
                        fname)
    shutil.copy(original,
                taeget)
#读取每个文件夹有多少张照片和类别
    import os
train_path=r"C:\Users\admin\Desktop\lml2103280114\test"
print('total test new images:', len(os.listdir(train_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\test\test_somking"
print('total test test_somking images:', len(os.listdir(valid_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\test\test_nosomking"
print('total test test_nosomking images:', len(os.listdir(valid_path)))
train_path=r"C:\Users\admin\Desktop\lml2103280114\train"
print('total train new images:', len(os.listdir(train_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\train\train_somking"
print('total train train_somking images:', len(os.listdir(valid_path)))
valid_path=r"C:\Users\admin\Desktop\lml2103280114\train\train_nosomking"
print('total train train_nosomking images:', len(os.listdir(valid_path)))
#图片预处理
#读取图片 
#图片解码
#图片预处理 
#图片归一化
from keras.preprocessing.image import ImageDataGenerator
train_datagen=ImageDataGenerator(rescale=1/255 )
test_datagen=ImageDataGenerator(rescale=1/255)
#建立生成器
train_dir=r'C:\Users\admin\Desktop\lml2103280114\train'

train_generator=train_datagen.flow_from_directory(train_dir,
                                                 target_size=(200,200),
                                                 batch_size=20,
                                                 class_mode='binary')
test_dir=r'C:\Users\admin\Desktop\lml2103280114\test'
#建立生成器
test_generator=train_datagen.flow_from_directory(test_dir,
                                                 target_size=(200,200),
                                                 batch_size=20,
                                                 class_mode='binary')
#建立模型
model=keras.Sequential()
from keras import layers
#卷积层1
model.add(layers.Conv2D(64, (3,3),activation='relu',input_shape=(200,200,3)))
#卷积层2
model.add(layers.Conv2D(64,(3,3), activation='relu'))
#最大值池化层1
model.add(layers.MaxPooling2D())
model.add(layers.Dropout(0.25))
#卷积层3
model.add(layers.Conv2D(64, (3,3),activation='relu'))
#卷积层4
model.add(layers.Conv2D(64,  (3,3),   activation='relu'))
#最大值池化层1
model.add(layers.MaxPooling2D())
model.add(layers.Dropout(0.25))
model.add(layers.Conv2D(64,(3,3),activation='relu'))
model.add(layers.Conv2D(64,(3,3),activation='relu'))
#最大值池化层1
model.add(layers.MaxPooling2D())
model.add(layers.Dropout(0.25))
model.add(layers.Flatten())
#全连接层1
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dense(1,activation='sigmoid'))
import tensorflow as tf
model.compile(optimizer=tf.keras.optimizers.Adam(lr=0.0001),
              loss='binary_crossentropy',
              metrics='acc')
#训练模型
result=model.fit_generator(train_generator,
                           epochs=20,
                           steps_per_epoch=30,
                            validation_data=test_generator,
                            validation_steps=50
)
#输出训练过程的历史数据
result.history
model.summary()
#将训练过程产生的数据保存为h5文件
from keras.models import load_model
model.save(r'C:\Users\admin\Desktop\lml2103280114\2103280114.h5')
#如何打开.h5文件
from keras.models import load_model
from keras import layers
from keras import models
model=load_model(r'C:\Users\admin\Desktop\lml2103280114\2103280114.h5')
#绘制训练过程中精度曲线
import matplotlib.pyplot as plt
acc = result.history['acc']
epochs = range(1, len(acc) + 1)
plt.plot(epochs,  acc, 'bo',  label='Training acc')
plt.title(' accuracy')
plt.legend()
#绘制训练过程中的损失曲线和精度曲线
import matplotlib.pyplot as plt
loss =result.history['loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs,loss, 'b',label='loss')
plt.title('loss')
plt.legend()
#绘制训练过程中的损失曲线和精度曲线
import matplotlib.pyplot as plt
acc = result.history['acc']
loss =result.history['loss']
epochs = range(1,
               len(acc) + 1)
plt.plot(epochs,acc, 'bo', label='Training acc')
plt.plot(epochs, loss, 'b',label='loss')
plt.title('Training and validation accuracy')
plt.legend()
# 从测试集中读取一条样本
from keras.utils import image_utils
#C:\Users\admin\Desktop\lml2103280114\train\train_somking
img_path = r"C:\Users\admin\Desktop\lml2103280114\train\train_somking\smoking_0001.jpg"
#img_path = r"C:\Users\admin\Desktop\cats_and_dogs_small\train\dogs\dog.168.jpg"
from keras.preprocessing import image
import numpy as np
img = image_utils.load_img(img_path, target_size=(150,150))
img_tensor = image_utils.img_to_array(img)
img_tensor = np.expand_dims(img_tensor, axis=0)
img_tensor /= 255.
print(img_tensor.shape)
#显示样本
import matplotlib.pyplot as plt
plt.imshow(img_tensor[0])
plt.show()
#显示第一层激活输出特的第一个滤波器的特征图
import matplotlib.pyplot as plt
first_layer_activation = activations[0]
plt.matshow(first_layer_activation[0,:,:,1],  cmap="viridis")
#存储层的名称
layer_names = []
for layer in model.layers[:4]:
    layer_names.append(layer.name)
# 每行显示16个特征图
images_pre_row = 16  #每行显示的特征图数
# 循环8次显示8层的全部特征图
for layer_name, layer_activation in zip(layer_names, activations):
    n_features = layer_activation.shape[-1] #保存当前层的特征图个数
    size = layer_activation.shape[1]  #保存当前层特征图的宽高
    n_col = n_features // images_pre_row #计算当前层显示多少行
    #生成显示图像的矩阵
    display_grid = np.zeros((size*n_col, images_pre_row*size))
    #遍历将每个特张图的数据写入到显示图像的矩阵中
    for col in range(n_col):
        for row in range(images_pre_row):
            #保存该张特征图的矩阵(size,size,1)
            channel_image = layer_activation[0,:,:,col*images_pre_row+row]
            #为使图像显示更鲜明，作一些特征处理
            channel_image -= channel_image.mean()
            channel_image /= channel_image.std()
            channel_image *= 64
            channel_image += 128 
            #把该特征图矩阵中不在0-255的元素值修改至0-255
            channel_image = np.clip(channel_image, 0, 255).astype("uint8")
            #该特征图矩阵填充至显示图像的矩阵中
            display_grid[col*size:(col+1)*size, row*size:(row+1)*size] = channel_image
    scale = 1./size
    #设置该层显示图像的宽高
    plt.figure(figsize=(scale*display_grid.shape[1],scale*display_grid.shape[0]))
    plt.title(layer_name)
    plt.grid(False)
    #显示图像
    plt.imshow(display_grid, aspect="auto", cmap="viridis")
 #预测
        ###导入模型
from keras.models import load_model
model = load_model(r'C:\Users\admin\Desktop\lml2103280114\2103280114.h5')
#model.summary()
img_scale = plt.imread( 'C:/Users/admin/Desktop/notsmoking_0001.JPG')
img_scale = img_scale.reshape(1,150,150,3).astype('float32')
img_scale = img_scale/255        #归一化到0-1之间
result = model.predict(img_scale) #取图片信息
#print(result)
img_scale = plt.imread('C:/Users/admin/Desktop/notsmoking_0001.JPG')

plt.imshow(img_scale)        #显示图片

if result>0.5:
    print('该图片是抽烟者的概率为：',result)
else:
    print('该图片是不抽烟者的概率为：',1-result)

总结：

通过对机器学习的学习，比较熟悉掌握了对数据的清洗，图片的分析，与识别，通过对抽烟者与不抽烟者这个项目的学习，发现自己还存在很多不足，在对项目预测的时候，由于模型预测次数较少，导致后面进行图片预测的时候精准度不是很高，虽然也预测正确了，但是精确的还有待提高。