當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

【人工智能与机器学习】——Keras编程分别实现人脸微笑和口罩数据集的识别模型训练和测试（卷积神经网络CNN） + 实时分类微笑和口罩识别检测

發布時間：2023/12/20 编程问答 34 豆豆

生活随笔收集整理的這篇文章主要介紹了【人工智能与机器学习】——Keras编程分别实现人脸微笑和口罩数据集的识别模型训练和测试（卷积神经网络CNN） + 实时分类微笑和口罩识别检测小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

機器學習練習目錄

一、理解人臉圖像特征提取的各種方法的特征
- 1.HOG
- 2.Dlib
- 3.卷積神經網絡（CNN）
二、卷積神經網絡（CNN）笑臉數據集（genki4k）正負樣本的劃分、模型訓練和測試的過程，輸出模型訓練精度和測試精度，完成對人臉微笑與否的模型訓練
- 1.查看運行的環境
- 2.數據集準備
- 3.網絡模型
- 4.資料預處理
- 5.開始訓練
- 6.使用數據填充
- 7.對人臉微笑與否的模型訓練
三、卷積神經網絡（CNN）對口罩數據集正負樣本的劃分、模型訓練和測試的過程，輸出模型訓練精度和測試精度，完成對口罩佩戴與否的模型訓練
- 1.數據集準備
- 2.網絡模型
- 3.資料預處理
- 4.開始訓練
- 5.使用數據填充
- 6.對人臉戴口罩與否的模型訓練
四、完成一個攝像頭采集自己人臉、并對表情（笑臉/非笑臉、戴口罩和沒戴口罩）的實時分類判讀（輸出分類文字）的程序
- 1.笑臉/非笑臉實時分類判讀（輸出分類文字）的程序
- 2.戴口罩和沒戴口罩的實時分類判讀（輸出分類文字）的程序

一、理解人臉圖像特征提取的各種方法的特征

1.HOG

介紹：方向梯度直方圖（Histogram of Oriented Gradient, HOG）特征是一種在計算機視覺和圖像處理中用來進行物體檢測的特征描述子。它通過計算和統計圖像局部區域的梯度方向直方圖來構成特征。
主要思想：在一副圖像中，局部目標的表象和形狀能夠被梯度或邊緣的方向密度分布很好地描述。（本質：梯度的統計信息，而梯度主要存在于邊緣的地方）。
具體的實現方法：首先將圖像分成小的連通區域，把它叫細胞單元。然后采集細胞單元中各像素點的梯度的或邊緣的方向直方圖。最后把這些直方圖組合起來就可以構成特征描述器。
步驟：灰度圖像轉換、梯度計算、分網格的梯度方向直方圖、快描述子、快描述子歸一化、特征數據與檢測窗口、匹配方法。
優點： ① HOG是在圖像的局部方格單元上操作，它對圖像幾何的和光學的形變都能保持很好的不變性，這兩種形變只會出現在更大的空間領域上；②在粗的空域抽樣、精細的方向抽樣以及較強的局部光學歸一化等條件下，只要行人大體上能夠保持直立的姿勢，可以容許行人有一些細微的肢體動作，這些細微的動作可以被忽略而不影響檢測效果。

綜上所述，HOG特征是特別適合于做圖像中的人體檢測的。

參考鏈接：https://zhuanlan.zhihu.com/p/104670289

2.Dlib

介紹： Dlib是一款優秀的跨平臺開源的C++工具庫，該庫使用C++編寫，具有優異的性能。Dlib庫提供的功能十分豐富，包括線性代數，圖像處理，機器學習，網絡，最優化算法等眾多功能。同時該庫也提供了Python接口。
核心原理：使用了圖像Hog特征來表示人臉，和其他特征提取算子相比，它對圖像的幾何和光學的形變都能保持很好的不變形。該特征與LBP特征，Harr特征共同作為三種經典的圖像特征，該特征提取算子通常和支持向量機(SVM)算法搭配使用，用在物體檢測場景。
該算法大致思路：

對正樣本(即包含人臉的圖像)數據集提取Hog特征，得到Hog特征描述子。
對負樣本(即不包含人臉的圖像)數據集提取Hog特征，得到Hog描述子。其中負樣本數據集中的數據量要遠遠大于正樣本數據集中的樣本數，負樣本圖像可以使用不含人臉的圖片進行隨機裁剪獲取。
利用支持向量機算法訓練正負樣本，顯然這是一個二分類問題，可以得到訓練后的模型。
利用該模型進行負樣本難例檢測，也就是難分樣本挖掘(hard-negtive mining)，以便提高最終模型的分類能力。具體思路為：對訓練集里的負樣本不斷進行縮放，直至與模板匹配位置，通過模板滑動串口搜索匹配（該過程即多尺度檢測過程），如果分類器誤檢出非人臉區域則截取該部分圖像加入到負樣本中。
集合難例樣本重新訓練模型，反復如此得到最終分類模型。
應用最終訓練出的分類器檢測人臉圖片，對該圖片的不同尺寸進行滑動掃描，提取Hog特征，并用分類器分類。如果檢測判定為人臉，則將其標定出來，經過一輪滑動掃描后必然會出現同一個人臉被多次標定的情況，這就用NMS完成收尾工作即可。

參考鏈接：https://zhuanlan.zhihu.com/p/92132280

3.卷積神經網絡（CNN）

介紹：卷積神經網絡（Convolutional Neural Networks, CNN）是一類包含卷積計算且具有深度結構的前饋神經網絡，是深度學習的代表算法之一。卷積神經網絡具有表征學習能力，能夠按其階層結構對輸入信息進行平移不變分類，因此也被稱為“平移不變人工神經網絡（SIANN）"。

CNN原理：卷積神經網絡（CNN）主要是用于圖像識別領域，它指的是一類網絡，而不是某一種，其包含很多不同種結構的網絡。不同的網絡結構通常表現會不一樣。
所有CNN最終都是把一張圖片轉化為特征向量。就像上圖VGG網絡一樣，通過多層的卷積，池化，全連接，降低圖片維度，最后轉化成了一個一維向量。這個向量就包含了圖片的特征，當然這個特征不是肉眼上的圖片特征，而是針對于神經網絡的特征。

CNN的訓練過程：

卷積神經網絡的前向傳播過程

前向傳播中的卷積操作
前向傳播中的池化操作
前向傳播中的全連接

卷積神經網絡的反向傳播過程
卷積神經網絡的權值更新
卷積神經網絡的訓練過程流程圖：

（不斷循環這個過程，最后得到一個穩定的權值和閾值)

CNN的應用：

圖片分類
相似圖搜索
對抗樣本（比如輸入一張貓的圖片，人為的修改一點圖片數據，肉眼上看還是一只貓，但是你告訴神經網絡這是狗。）

參考鏈接：https://zhuanlan.zhihu.com/p/95158245

二、卷積神經網絡（CNN）笑臉數據集（genki4k）正負樣本的劃分、模型訓練和測試的過程，輸出模型訓練精度和測試精度，完成對人臉微笑與否的模型訓練

1.查看運行的環境

import platform import tensorflow import kerasprint("Platform: {}".format(platform.platform())) print("Tensorflow version: {}".format(tensorflow.__version__)) print("Keras version: {}".format(keras.__version__)) Platform: Windows-7-6.1.7601-SP1 Tensorflow version: 1.2.1 Keras version: 2.1.2

2.數據集準備

下載圖像數據集genki4k.tar，把它解壓到相應的目錄（我放在了D:\mango目錄下），解壓出來看見的原始數據集內容如圖所示
手動裁剪過程
其中裁剪之前的圖片
對圖像進行了裁剪，提取大頭照，并把一些不符合的圖片進行了剔除，執行完裁剪后的顯示效果
由于各種原因沒有裁剪剔除的圖片
導入需要的包

import keras #導入人工神經網絡庫 import matplotlib.pyplot as plt # matplotlib進行畫圖 import matplotlib.image as mpimg # # mpimg 用于讀取圖片 import numpy as np # numpy操作數組 from IPython.display import Image #顯示圖像 import os #os：操作系統接口

劃分數據集（在當前寫代碼的同級目錄下會產生一個mangoout的文件夾，包括 train :訓練集；validation：驗證集；test：測試集。）

# 原目錄的路徑 original_dataset_dir = 'D:\\mango\\files\\cutmango'# 結果路徑，存儲較小的數據集 base_dir = 'mangoout' os.mkdir(base_dir)# 訓練目錄，驗證和測試拆分 train_dir = os.path.join(base_dir, 'train') os.mkdir(train_dir) validation_dir = os.path.join(base_dir, 'validation') os.mkdir(validation_dir) test_dir = os.path.join(base_dir, 'test') os.mkdir(test_dir)# 訓練微笑圖片目錄 train_smile_dir = os.path.join(train_dir, 'smile') os.mkdir(train_smile_dir)# 訓練沒微笑圖片目錄 train_unsmile_dir = os.path.join(train_dir, 'unsmile') #s.mkdir(train_dogs_dir)# 驗證的微笑圖片目錄 validation_smile_dir = os.path.join(validation_dir, 'smile') os.mkdir(validation_smile_dir)# 驗證的沒微笑圖片目錄 validation_unsmile_dir = os.path.join(validation_dir, 'unsmile') os.mkdir(validation_unsmile_dir)# 測試的微笑圖片目錄 test_smile_dir = os.path.join(test_dir, 'smile') os.mkdir(test_smile_dir)# 測試的沒微笑圖片目錄 test_unsmile_dir = os.path.join(test_dir, 'unsmile') os.mkdir(test_unsmile_dir)

分配數據集，可以使用人為劃分和代碼劃分
進行一次檢查，計算每個分組中有多少張照片(訓練/驗證/測試)

print('total training smile images:', len(os.listdir(train_smile_dir))) total training smile images: 1000 print('total testing smile images:', len(os.listdir(test_smile_dir))) total testing smile images: 300 print('total training unsmile images:', len(os.listdir(train_unsmile_dir))) total training unsmile images: 1000 print('total validation smile images:', len(os.listdir(validation_smile_dir))) total validation smile images: 300 print('total testing unsmile images:', len(os.listdir(test_unsmile_dir))) total testing unsmile images: 300 print('total validation unsmile images:', len(os.listdir(validation_unsmile_dir))) total validation unsmile images: 300

有2000個訓練圖像，然后是600個驗證圖像，600個測試圖像，其中每個分類都有相同數量的樣本，是一個平衡的二元分類問題，意味著分類準確度將是合適的度量標準。

3.網絡模型

卷積網絡(convnets)將是一組交替的Conv2D(具有relu激活)和MaxPooling2D層。從大小150x150（有點任意選擇）的輸入開始，我們最終得到了尺寸為７x7的Flatten層之前的特征圖。
注意特征圖的深度在網絡中逐漸增加(從32到128)，而特征圖的大小正在減少(從148x148到7x7)。這是一個你將在幾乎所有的卷積網絡(convnets)結構中會看到的模式。
由于我們正在處理二元分類問題，所以我們用一個神經元（一個大小為１的密集層(Dense))和一個sigmoid激活函數來結束網絡。該神經元將會被用來查看圖像歸屬于那一類或另一類的概率。

創建模型

from keras import layers from keras import models model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu',input_shape=(150, 150, 3))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(1, activation='sigmoid'))

看特征圖的尺寸如何隨著每個連續的圖層而改變，打印網絡結構

model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_5 (Conv2D) (None, 148, 148, 32) 896 _________________________________________________________________ max_pooling2d_5 (MaxPooling2 (None, 74, 74, 32) 0 _________________________________________________________________ conv2d_6 (Conv2D) (None, 72, 72, 64) 18496 _________________________________________________________________ max_pooling2d_6 (MaxPooling2 (None, 36, 36, 64) 0 _________________________________________________________________ conv2d_7 (Conv2D) (None, 34, 34, 128) 73856 _________________________________________________________________ max_pooling2d_7 (MaxPooling2 (None, 17, 17, 128) 0 _________________________________________________________________ conv2d_8 (Conv2D) (None, 15, 15, 128) 147584 _________________________________________________________________ max_pooling2d_8 (MaxPooling2 (None, 7, 7, 128) 0 _________________________________________________________________ flatten_2 (Flatten) (None, 6272) 0 _________________________________________________________________ dense_3 (Dense) (None, 512) 3211776 _________________________________________________________________ dense_4 (Dense) (None, 1) 513 ================================================================= Total params: 3,453,121 Trainable params: 3,453,121 Non-trainable params: 0 _________________________________________________________________

在編譯步驟里，使用RMSprop優化器。由于用一個單一的神經元(Sigmoid的激活函數）結束了網絡，將使用二進制交叉熵(binary crossentropy)作為損失函數

from keras import optimizersmodel.compile(loss='binary_crossentropy',optimizer=optimizers.RMSprop(lr=1e-4),metrics=['acc'])

4.資料預處理

網絡的預處理步驟：
讀入圖像

將JPEG內容解碼為RGB網格的像素

將其轉換為浮點張量

將像素值(0和255之間)重新縮放到[0,1]間隔

數據應該先被格式化成適當的預處理浮點張量，然后才能輸入到神經網絡中

from keras.preprocessing.image import ImageDataGenerator # 所有的圖像將重新進行歸一化處理　Rescaled by 1./255 train_datagen = ImageDataGenerator(rescale=1./255) validation_datagen=ImageDataGenerator(rescale=1./255) test_datagen = ImageDataGenerator(rescale=1./255) # 直接從目錄讀取圖像數據 train_generator = train_datagen.flow_from_directory(# 訓練圖像的目錄train_dir,# 所有圖像大小會被轉換成150x150target_size=(150, 150),# 每次產生20個圖像的批次batch_size=20,# 由于這是一個二元分類問題，y的label值也會被轉換成二元的標簽class_mode='binary') # 直接從目錄讀取圖像數據 validation_generator = test_datagen.flow_from_directory(validation_dir,target_size=(150, 150),batch_size=20,class_mode='binary') test_generator = test_datagen.flow_from_directory(test_dir,target_size=(150, 150),batch_size=20,class_mode='binary') Found 2000 images belonging to 2 classes. Found 600 images belonging to 2 classes. Found 600 images belonging to 2 classes.

圖像張量生成器(generator)的輸出，它產生150x150 RGB圖像(形狀"(20,150,150,3)")和二進制標簽(形狀"(20,)")的批次張量。20是每個批次中的樣品數(批次大小)

for data_batch, labels_batch in train_generator:print('data batch shape:', data_batch.shape)print('labels batch shape:', labels_batch)break data batch shape: (20, 150, 150, 3) labels batch shape: [ 1. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 0.0. 0.]

輸出結果的0（笑臉）和1（非笑臉）

train_generator.class_indices {'smile': 0, 'unsmile': 1}

5.開始訓練

其中epochs值越大，花費的時間就越久、訓練的精度更高，我電腦性能不好，運行了很久… …

history = model.fit_generator(train_generator,steps_per_epoch=100,epochs=10,validation_data=validation_generator,validation_steps=50) Epoch 1/10 100/100 [==============================] - 227s 2s/step - loss: 0.6776 - acc: 0.5740 - val_loss: 0.6745 - val_acc: 0.5660 Epoch 2/10 100/100 [==============================] - 230s 2s/step - loss: 0.6422 - acc: 0.6520 - val_loss: 0.7091 - val_acc: 0.5290 Epoch 3/10 100/100 [==============================] - 222s 2s/step - loss: 0.5889 - acc: 0.7020 - val_loss: 0.5711 - val_acc: 0.7530 Epoch 4/10 100/100 [==============================] - 192s 2s/step - loss: 0.5251 - acc: 0.7575 - val_loss: 0.5592 - val_acc: 0.7330 Epoch 5/10 100/100 [==============================] - 191s 2s/step - loss: 0.4854 - acc: 0.7825 - val_loss: 0.5250 - val_acc: 0.7550 Epoch 6/10 100/100 [==============================] - 184s 2s/step - loss: 0.4503 - acc: 0.8015 - val_loss: 0.5111 - val_acc: 0.7980 Epoch 7/10 100/100 [==============================] - 183s 2s/step - loss: 0.4111 - acc: 0.8255 - val_loss: 0.5376 - val_acc: 0.7500 Epoch 8/10 100/100 [==============================] - 189s 2s/step - loss: 0.3748 - acc: 0.8380 - val_loss: 0.4906 - val_acc: 0.7850 Epoch 9/10 100/100 [==============================] - 188s 2s/step - loss: 0.3493 - acc: 0.8590 - val_loss: 0.4397 - val_acc: 0.8170 Epoch 10/10 100/100 [==============================] - 186s 2s/step - loss: 0.3177 - acc: 0.8670 - val_loss: 0.4265 - val_acc: 0.8400

訓練完成后把模型保存下來

model.save('mangoout/smileAndUnsmile_1.h5')

使用圖表來繪制在訓練過程中模型對訓練和驗證數據的損失(loss)和準確性(accuracy)數據

import matplotlib.pyplot as plt acc = history.history['acc'] val_acc = history.history['val_acc'] loss = history.history['loss'] val_loss = history.history['val_loss'] epochs = range(len(acc)) plt.plot(epochs, acc, 'bo', label='Training acc') plt.plot(epochs, val_acc, 'b', label='Validation acc') plt.title('Training and validation accuracy') plt.legend() plt.figure() plt.plot(epochs, loss, 'bo', label='Training loss') plt.plot(epochs, val_loss, 'b', label='Validation loss') plt.title('Training and validation loss') plt.legend() plt.show()

可能由于我們提前對圖片進行了裁剪篩選操作，過度擬合這里不是太能體現出來，訓練精確度隨著時間線性增長，驗證精度也在增長。
驗證損失和訓練損失都在線性上保持下降直到接近０。

💥 為了進一步優化，下面會引入一個新的、特定于電腦視覺影像，并在使用深度學習模型處理圖像時幾乎普遍使用的技巧:數據擴充(data augmentation)

6.使用數據填充

數據增加采用從現有訓練樣本生成更多訓練數據的方法，通過產生可信的圖像的多個隨機變換來"增加"樣本。目標是在訓練的時候，我們的模型永遠不會再看到完全相同的畫面兩次。這有助于模型學習到數據的更多方面，并更好地推廣。

在keras中，可以通過配置對ImageDataGenerator實例讀取的圖像執行多個隨機變換來完成

datagen = ImageDataGenerator(rotation_range=40,width_shift_range=0.2,height_shift_range=0.2,shear_range=0.2,zoom_range=0.2,horizontal_flip=True,fill_mode='nearest')

這里列出一些可用的選項(更多選項，可以參考keras文檔），快速看一下這些參數:
rotation_range 是以度（0-180)為單位的值，它是隨機旋轉圖片的范圍
width_shift 和 height_shift 是范圍(占總寬度或高度的一小部分),用于縱向或橫向隨機轉換圖片
shear_range 用于隨機剪切變換
zoom_range 用于隨機放大圖片內容
horizontal_flip 用于在沒有水平不對稱假設（例如真實世界圖片）的情況下水平地隨機翻轉一半圖像
fill_mode 是用于填充新創建的像素的策略，可以在旋轉或寬/高移位后顯示

看增強后的圖像

import matplotlib.pyplot as plt # 圖像預處理功能模塊 from keras.preprocessing import image # 取得訓練數據集中微笑的圖片列表 fnames = [os.path.join(train_smile_dir, fname) for fname in os.listdir(train_smile_dir)] img_path = fnames[3] # 取一個圖像 img = image.load_img(img_path, target_size=(150, 150)) # 讀入圖像并進行大小處理 x = image.img_to_array(img) # 轉換成Numpy array 并且shape(150,150,3) x = x.reshape((1,) + x.shape) # 重新Reshape成(1,150,150,3)以便輸入到模型中 # 通過flow()方法將會隨機產生新的圖像，它會無線循環，所以我們需要在某個時候“斷開”循環 i = 0 for batch in datagen.flow(x, batch_size=1):plt.figure(i)imgplot = plt.imshow(image.array_to_img(batch[0]))i += 1if i % 4 == 0:break plt.show()

如果我們使用這種數據增強配置來訓練一個新的網絡，我們的網絡將永遠不會看到相同重復的輸入。

然而，它看到的輸入仍然是相互關聯的，因為它們來自少量的原始圖像 - 我們不能產生新的信息，我們只能重新混合現有的信息。
因此，這可能不足以完全擺脫過度擬合(overfitting)。為了進一步克服過度擬合(overfitting)，我們還將在密集連接(densely-connected)的分類器之前添加一個Dropout層。

model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu',input_shape=(150, 150, 3))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dropout(0.5)) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy',optimizer=optimizers.RMSprop(lr=1e-4),metrics=['acc'])

使用數據填充(data augmentation)和dropout來訓練我們的網絡

#歸一化處理 train_datagen = ImageDataGenerator(rescale=1./255,rotation_range=40,width_shift_range=0.2,height_shift_range=0.2,shear_range=0.2,zoom_range=0.2,horizontal_flip=True,)# 注意，驗證數據不應該擴充 test_datagen = ImageDataGenerator(rescale=1./255)train_generator = train_datagen.flow_from_directory(# 這是圖像資料的目錄train_dir,# 所有的圖像大小會被轉換成150x150target_size=(150, 150),batch_size=32,# 由于這是一個二元分類問題，y的label值也會被轉換成二元的標簽class_mode='binary')validation_generator = test_datagen.flow_from_directory(validation_dir,target_size=(150, 150),batch_size=32,class_mode='binary')history = model.fit_generator(train_generator,steps_per_epoch=100,epochs=60, validation_data=validation_generator,validation_steps=50) Found 2000 images belonging to 2 classes. Found 600 images belonging to 2 classes. Epoch 1/60 100/100 [==============================] - 377s 4s/step - loss: 0.6905 - acc: 0.5312 - val_loss: 0.6815 - val_acc: 0.5587 Epoch 2/60 100/100 [==============================] - 303s 3s/step - loss: 0.6849 - acc: 0.5550 - val_loss: 0.6768 - val_acc: 0.5852 Epoch 3/60 100/100 [==============================] - 314s 3s/step - loss: 0.6790 - acc: 0.5866 - val_loss: 0.6748 - val_acc: 0.5777 Epoch 4/60 100/100 [==============================] - 312s 3s/step - loss: 0.6774 - acc: 0.5806 - val_loss: 0.6722 - val_acc: 0.5821 Epoch 5/60 100/100 [==============================] - 303s 3s/step - loss: 0.6696 - acc: 0.5869 - val_loss: 0.6734 - val_acc: 0.5909 Epoch 6/60 100/100 [==============================] - 300s 3s/step - loss: 0.6665 - acc: 0.5956 - val_loss: 0.6679 - val_acc: 0.6029 Epoch 7/60 100/100 [==============================] - 309s 3s/step - loss: 0.6719 - acc: 0.5853 - val_loss: 0.6836 - val_acc: 0.5814 Epoch 8/60 100/100 [==============================] - 299s 3s/step - loss: 0.6628 - acc: 0.6031 - val_loss: 0.7166 - val_acc: 0.5600 Epoch 9/60 100/100 [==============================] - 310s 3s/step - loss: 0.6676 - acc: 0.6009 - val_loss: 0.6723 - val_acc: 0.6048 Epoch 10/60 100/100 [==============================] - 309s 3s/step - loss: 0.6629 - acc: 0.6100 - val_loss: 0.6546 - val_acc: 0.6288 Epoch 11/60 100/100 [==============================] - 300s 3s/step - loss: 0.6558 - acc: 0.6163 - val_loss: 0.6744 - val_acc: 0.6073 Epoch 12/60 100/100 [==============================] - 300s 3s/step - loss: 0.6575 - acc: 0.6216 - val_loss: 0.6425 - val_acc: 0.6572 Epoch 13/60 100/100 [==============================] - 307s 3s/step - loss: 0.6541 - acc: 0.6294 - val_loss: 0.7095 - val_acc: 0.5960 Epoch 14/60 100/100 [==============================] - 303s 3s/step - loss: 0.6429 - acc: 0.6400 - val_loss: 0.6381 - val_acc: 0.6414 Epoch 15/60 100/100 [==============================] - 310s 3s/step - loss: 0.6427 - acc: 0.6300 - val_loss: 0.6297 - val_acc: 0.6723 Epoch 16/60 100/100 [==============================] - 308s 3s/step - loss: 0.6404 - acc: 0.6369 - val_loss: 0.6254 - val_acc: 0.6667 Epoch 17/60 100/100 [==============================] - 301s 3s/step - loss: 0.6367 - acc: 0.6500 - val_loss: 0.6145 - val_acc: 0.6408 Epoch 18/60 100/100 [==============================] - 301s 3s/step - loss: 0.6246 - acc: 0.6450 - val_loss: 0.5991 - val_acc: 0.6831 Epoch 19/60 100/100 [==============================] - 307s 3s/step - loss: 0.6230 - acc: 0.6625 - val_loss: 0.5956 - val_acc: 0.7052 Epoch 20/60 100/100 [==============================] - 303s 3s/step - loss: 0.6062 - acc: 0.6725 - val_loss: 0.5812 - val_acc: 0.6951 Epoch 21/60 100/100 [==============================] - 301s 3s/step - loss: 0.6094 - acc: 0.6647 - val_loss: 0.5640 - val_acc: 0.7033 Epoch 22/60 100/100 [==============================] - 303s 3s/step - loss: 0.6089 - acc: 0.6794 - val_loss: 0.5698 - val_acc: 0.6774 Epoch 23/60 100/100 [==============================] - 305s 3s/step - loss: 0.5846 - acc: 0.6869 - val_loss: 0.5458 - val_acc: 0.7311 Epoch 24/60 100/100 [==============================] - 300s 3s/step - loss: 0.5782 - acc: 0.7022 - val_loss: 0.5380 - val_acc: 0.7551 Epoch 25/60 100/100 [==============================] - 303s 3s/step - loss: 0.5676 - acc: 0.7112 - val_loss: 0.5731 - val_acc: 0.7109 Epoch 26/60 100/100 [==============================] - 305s 3s/step - loss: 0.5711 - acc: 0.7134 - val_loss: 0.5303 - val_acc: 0.7121 Epoch 27/60 100/100 [==============================] - 315s 3s/step - loss: 0.5565 - acc: 0.7166 - val_loss: 0.4785 - val_acc: 0.7942 Epoch 28/60 100/100 [==============================] - 307s 3s/step - loss: 0.5462 - acc: 0.7269 - val_loss: 0.5904 - val_acc: 0.7052 Epoch 29/60 100/100 [==============================] - 309s 3s/step - loss: 0.5367 - acc: 0.7309 - val_loss: 0.4601 - val_acc: 0.7847 Epoch 30/60 100/100 [==============================] - 304s 3s/step - loss: 0.5283 - acc: 0.7359 - val_loss: 0.5043 - val_acc: 0.7532 Epoch 31/60 100/100 [==============================] - 302s 3s/step - loss: 0.5202 - acc: 0.7472 - val_loss: 0.5292 - val_acc: 0.7424 Epoch 32/60 100/100 [==============================] - 308s 3s/step - loss: 0.5147 - acc: 0.7531 - val_loss: 0.5043 - val_acc: 0.7860 Epoch 33/60 100/100 [==============================] - 305s 3s/step - loss: 0.5100 - acc: 0.7434 - val_loss: 0.4506 - val_acc: 0.7955 Epoch 34/60 100/100 [==============================] - 303s 3s/step - loss: 0.5067 - acc: 0.7628 - val_loss: 0.4423 - val_acc: 0.7803 Epoch 35/60 100/100 [==============================] - 303s 3s/step - loss: 0.4937 - acc: 0.7591 - val_loss: 0.4281 - val_acc: 0.8037 Epoch 36/60 100/100 [==============================] - 300s 3s/step - loss: 0.4903 - acc: 0.7619 - val_loss: 0.4191 - val_acc: 0.8125 Epoch 37/60 100/100 [==============================] - 299s 3s/step - loss: 0.4704 - acc: 0.7769 - val_loss: 0.4266 - val_acc: 0.8213 Epoch 38/60 100/100 [==============================] - 307s 3s/step - loss: 0.4811 - acc: 0.7778 - val_loss: 0.4196 - val_acc: 0.8239 Epoch 39/60 100/100 [==============================] - 312s 3s/step - loss: 0.4722 - acc: 0.7753 - val_loss: 0.4366 - val_acc: 0.7992 Epoch 40/60 100/100 [==============================] - 301s 3s/step - loss: 0.4694 - acc: 0.7797 - val_loss: 0.4597 - val_acc: 0.7879 Epoch 41/60 100/100 [==============================] - 304s 3s/step - loss: 0.4658 - acc: 0.7866 - val_loss: 0.4021 - val_acc: 0.8239 Epoch 42/60 100/100 [==============================] - 303s 3s/step - loss: 0.4700 - acc: 0.7859 - val_loss: 0.4271 - val_acc: 0.8100 Epoch 43/60 100/100 [==============================] - 300s 3s/step - loss: 0.4591 - acc: 0.7850 - val_loss: 0.4687 - val_acc: 0.7898 Epoch 44/60 100/100 [==============================] - 308s 3s/step - loss: 0.4592 - acc: 0.7847 - val_loss: 0.4136 - val_acc: 0.8169 Epoch 45/60 100/100 [==============================] - 311s 3s/step - loss: 0.4449 - acc: 0.8031 - val_loss: 0.4427 - val_acc: 0.7784 Epoch 46/60 100/100 [==============================] - 299s 3s/step - loss: 0.4505 - acc: 0.7897 - val_loss: 0.4030 - val_acc: 0.8220 Epoch 47/60 100/100 [==============================] - 306s 3s/step - loss: 0.4515 - acc: 0.7978 - val_loss: 0.4324 - val_acc: 0.7948 Epoch 48/60 100/100 [==============================] - 303s 3s/step - loss: 0.4485 - acc: 0.8025 - val_loss: 0.4979 - val_acc: 0.7544 Epoch 49/60 100/100 [==============================] - 303s 3s/step - loss: 0.4310 - acc: 0.8137 - val_loss: 0.4203 - val_acc: 0.8100 Epoch 50/60 100/100 [==============================] - 309s 3s/step - loss: 0.4327 - acc: 0.8044 - val_loss: 0.4064 - val_acc: 0.8194 Epoch 51/60 100/100 [==============================] - 313s 3s/step - loss: 0.4308 - acc: 0.8091 - val_loss: 0.4266 - val_acc: 0.7891 Epoch 52/60 100/100 [==============================] - 307s 3s/step - loss: 0.4321 - acc: 0.7997 - val_loss: 0.4612 - val_acc: 0.8169 Epoch 53/60 100/100 [==============================] - 303s 3s/step - loss: 0.4316 - acc: 0.8081 - val_loss: 0.4235 - val_acc: 0.7942 Epoch 54/60 100/100 [==============================] - 302s 3s/step - loss: 0.4226 - acc: 0.8135 - val_loss: 0.4083 - val_acc: 0.8302 Epoch 55/60 100/100 [==============================] - 300s 3s/step - loss: 0.4240 - acc: 0.8062 - val_loss: 0.3863 - val_acc: 0.8340 Epoch 56/60 100/100 [==============================] - 308s 3s/step - loss: 0.4139 - acc: 0.8184 - val_loss: 0.4100 - val_acc: 0.8232 Epoch 57/60 100/100 [==============================] - 303s 3s/step - loss: 0.4149 - acc: 0.8159 - val_loss: 0.3911 - val_acc: 0.8239 Epoch 58/60 100/100 [==============================] - 305s 3s/step - loss: 0.4171 - acc: 0.8113 - val_loss: 0.3851 - val_acc: 0.8321 Epoch 59/60 100/100 [==============================] - 304s 3s/step - loss: 0.4221 - acc: 0.8141 - val_loss: 0.4243 - val_acc: 0.7891 Epoch 60/60 100/100 [==============================] - 303s 3s/step - loss: 0.4019 - acc: 0.8262 - val_loss: 0.3919 - val_acc: 0.8371

再次查看0或1含義

train_generator.class_indices {'smile': 0, 'unsmile': 1}

保存模型，將在convnet可視化里使用它

#保存模型 model.save('mangoout/smileAndUnsmile_2.h5')

保存模型文件夾顯示效果
繪制數據增強后的訓練集與驗證集的精確度與損失度的圖形，看一遍結果

acc = history.history['acc'] val_acc = history.history['val_acc'] loss = history.history['loss'] val_loss = history.history['val_loss']epochs = range(len(acc))plt.plot(epochs, acc, 'bo', label='Training acc') plt.plot(epochs, val_acc, 'b', label='Validation acc') plt.title('Training and validation accuracy') plt.legend()plt.figure()plt.plot(epochs, loss, 'bo', label='Training loss') plt.plot(epochs, val_loss, 'b', label='Validation loss') plt.title('Training and validation loss') plt.legend()plt.show()

由于數據增加(data augmentation)和dropout使用，不再有過度擬合(overfitting)的問題；訓練曲線相當密切地跟隨著驗證曲線。訓練精度和驗證精度經過60個循環接近85%。
通過進一步利用正規化技術，及調整網絡參數(例如每個卷積層的濾波器數量或網絡層數)，可以獲得更好的準確度。

7.對人臉微笑與否的模型訓練

判斷的第一張圖片（D:/mango/mangotest.jpg路徑下）

這就是訓練集中的某張圖片

# 單張圖片進行判斷是笑臉還是非笑臉 from keras.preprocessing import image from keras.models import load_model import numpy as np #加載模型 model = load_model('mangoout/smileAndUnsmile_2.h5') #本地圖片路徑 img_path='D:/mango/mangotest.jpg' img = image.load_img(img_path, target_size=(150, 150))img_tensor = image.img_to_array(img)/255.0 img_tensor = np.expand_dims(img_tensor, axis=0) prediction =model.predict(img_tensor) print(prediction) if prediction[0][0]>0.5:result='非笑臉' else:result='笑臉' print(result) [[ 0.00120554]] 笑臉

可以看見，判斷為笑臉是正確的。

判斷的第二張圖片（D:/mango/mangotest2.jpg路徑下）

這是我假期無聊時用美圖拍的，哈哈… … ??

# 單張圖片進行判斷是笑臉還是非笑臉 from keras.preprocessing import image from keras.models import load_model import numpy as np #加載模型 model = load_model('mangoout/smileAndUnsmile_2.h5') #本地圖片路徑 img_path='D:/mango/mangotest2.jpg' img = image.load_img(img_path, target_size=(150, 150))img_tensor = image.img_to_array(img)/255.0 img_tensor = np.expand_dims(img_tensor, axis=0) prediction =model.predict(img_tensor) print(prediction) if prediction[0][0]>0.5:result='非笑臉' else:result='笑臉' print(result) [[ 0.69130015]] 非笑臉

可以看見，判斷為非笑臉是正確的。

判斷的第三張圖片（D:/mango/mengmengsmile.jpg路徑下）

她自己拍的，順便被我拿來做作業，哈哈… …

# 單張圖片進行判斷是笑臉還是非笑臉 from keras.preprocessing import image from keras.models import load_model import numpy as np #加載模型 model = load_model('mangoout/smileAndUnsmile_1.h5') #本地圖片路徑 img_path='D:/mango/mengmengsmile.jpg' img = image.load_img(img_path, target_size=(150, 150))img_tensor = image.img_to_array(img)/255.0 img_tensor = np.expand_dims(img_tensor, axis=0) prediction =model.predict(img_tensor) print(prediction) if prediction[0][0]>0.5:result='非笑臉' else:result='笑臉' print(result) [[ 0.03113164]] 笑臉

可以看見，判斷為笑臉是正確的（但是有一些圖片中人臉部分在整張圖片的占比不是在特別多的話，它判斷出來的準確度就比較小，甚至出現判斷錯誤的情況，但是一般大頭照判斷出來的準確度還是很高的。）

三、卷積神經網絡（CNN）對口罩數據集正負樣本的劃分、模型訓練和測試的過程，輸出模型訓練精度和測試精度，完成對口罩佩戴與否的模型訓練

1.數據集準備

下載口罩數據集，把它解壓到相應的目錄（我放在了D:\mangomask目錄下）
解壓后原始有口罩的數據集顯示效果
解壓后原始沒有口罩的數據集顯示效果
將正樣本（有口罩）數據集重命名為連續序列，以便后面調整

#coding:utf-8 import os path = "D:/mangomask/mask/have_mask" # 人臉口罩數據集正樣本的路徑 filelist = os.listdir(path) count=1000 #開始文件名1000.jpg for file in filelist: Olddir=os.path.join(path,file) if os.path.isdir(Olddir): continuefilename=os.path.splitext(file)[0] filetype=os.path.splitext(file)[1]Newdir=os.path.join(path,str(count)+filetype) os.rename(Olddir,Newdir)count+=1

對數據集重命名后，人臉正樣本（有口罩）數據集顯示效果如下
將負樣本（沒有口罩）數據集重命名為連續序列，以便后面調整

#coding:utf-8 import os path = "D:/mangomask/mask/no_mask" # 人臉口罩數據集負樣本的路徑 filelist = os.listdir(path) count=10000 #開始文件名1000.jpg for file in filelist: Olddir=os.path.join(path,file) if os.path.isdir(Olddir): continuefilename=os.path.splitext(file)[0] filetype=os.path.splitext(file)[1]Newdir=os.path.join(path,str(count)+filetype) os.rename(Olddir,Newdir)count+=1

對數據集重命名后，人臉負樣本（沒有口罩）數據集顯示效果如下
正負樣本數據集像素處理

正樣本（有口罩）數據集的像素設置為 20x20，模型訓練精度更高；

負樣本（沒有口罩）數據集像素設置不低于50x50，加快模型訓練的速度。

1.調整正樣本（有口罩）像素

import pandas as pd import cv2 for n in range(1000,1606):#代表正數據集中開始和結束照片的數字path='D:/mangomask/mask/have_mask/'+str(n)+'.jpg'# 讀取圖片img = cv2.imread(path)img=cv2.resize(img,(20,20)) #修改樣本像素為20x20cv2.imwrite('D:/mangomask/mask/have_mask/' + str(n) + '.jpg', img)n += 1

調整正樣本（有口罩）像素后，數據集圖像顯示效果

2.調整負樣本（沒有口罩）像素

#修改負樣本像素 import pandas as pd import cv2 for n in range(10000,11790):#代表負樣本數據集中開始和結束照片的數字path='D:/mangomask/mask/no_mask/'+str(n)+'.jpg'# 讀取圖片img = cv2.imread(path)img=cv2.resize(img,(80,80)) #修改樣本像素為60x60cv2.imwrite('D:/mangomask/mask/no_mask/' + str(n) + '.jpg', img)n += 1

調整負樣本（沒有口罩）像素后，數據集圖像顯示效果
劃分數據集（在當前寫代碼的同級目錄下會產生一個maskout的文件夾，包括 train :訓練集；validation：驗證集；test：測試集。）

original_dataset_dir = 'D://mangomask//mask' # 原始數據集的路徑base_dir = 'maskout' # 存放圖像數據集的目錄 os.mkdir(base_dir)train_dir = os.path.join(base_dir, 'train') # 訓練圖像的目錄 os.mkdir(train_dir) validation_dir = os.path.join(base_dir, 'validation') # 驗證圖像的目錄 os.mkdir(validation_dir) test_dir = os.path.join(base_dir, 'test') # 測試圖像的目錄 os.mkdir(test_dir)train_havemask_dir = os.path.join(train_dir, 'have_mask') # 有口罩的圖片的訓練資料的目錄 os.mkdir(train_havemask_dir)train_nomask_dir = os.path.join(train_dir, 'no_mask') # 沒有口罩的圖片的訓練資料的目錄 os.mkdir(train_nomask_dir)validation_havemask_dir = os.path.join(validation_dir, 'have_mask') # 有口罩的圖片的驗證集目錄 os.mkdir(validation_havemask_dir)validation_nomask_dir = os.path.join(validation_dir, 'no_mask')# 沒有口罩的圖片的驗證集目錄 os.mkdir(validation_nomask_dir)test_havemask_dir = os.path.join(test_dir, 'have_mask') # 有口罩的圖片的測試數據集目錄 os.mkdir(test_havemask_dir)test_nomask_dir = os.path.join(test_dir, 'no_mask') # 沒有口罩的圖片的測試數據集目錄 os.mkdir(test_nomask_dir)

分配數據集，可以使用人為劃分和代碼劃分
進行一次檢查，計算每個分組中有多少張照片(訓練/驗證/測試)

print('total training havemask images:', len(os.listdir(train_havemask_dir))) total training havemask images: 300 print('total testing havemask images:', len(os.listdir(test_havemask_dir))) total testing havemask images: 150 print('total training nomask images:', len(os.listdir(train_nomask_dir))) total training nomask images: 300 print('total validation havemask images:', len(os.listdir(validation_havemask_dir))) total validation havemask images: 150 print('total testing nomask images:', len(os.listdir(test_nomask_dir))) total testing nomask images: 150 print('total validation nomask images:', len(os.listdir(validation_nomask_dir))) total validation nomask images: 150

有600個訓練圖像，然后是300個驗證圖像，300個測試圖像，其中每個分類都有相同數量的樣本，是一個平衡的二元分類問題，意味著分類準確度將是合適的度量標準。

2.網絡模型

卷積網絡(convnets)將是一組交替的Conv2D(具有relu激活)和MaxPooling2D層。從大小150x150（有點任意選擇）的輸入開始，我們最終得到了尺寸為７x7的Flatten層之前的特征圖。
注意特征圖的深度在網絡中逐漸增加(從32到128)，而特征圖的大小正在減少(從148x148到7x7)。這是一個你將在幾乎所有的卷積網絡(convnets)結構中會看到的模式。
由于我們正在處理二元分類問題，所以我們用一個神經元（一個大小為１的密集層(Dense))和一個sigmoid激活函數來結束網絡。該神經元將會被用來查看圖像歸屬于那一類或另一類的概率。

創建模型

#創建模型 from keras import layers from keras import modelsmodel = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu',input_shape=(150, 150, 3))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(1, activation='sigmoid'))

看特征圖的尺寸如何隨著每個連續的圖層而改變，打印網絡結構

model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_13 (Conv2D) (None, 148, 148, 32) 896 _________________________________________________________________ max_pooling2d_13 (MaxPooling (None, 74, 74, 32) 0 _________________________________________________________________ conv2d_14 (Conv2D) (None, 72, 72, 64) 18496 _________________________________________________________________ max_pooling2d_14 (MaxPooling (None, 36, 36, 64) 0 _________________________________________________________________ conv2d_15 (Conv2D) (None, 34, 34, 128) 73856 _________________________________________________________________ max_pooling2d_15 (MaxPooling (None, 17, 17, 128) 0 _________________________________________________________________ conv2d_16 (Conv2D) (None, 15, 15, 128) 147584 _________________________________________________________________ max_pooling2d_16 (MaxPooling (None, 7, 7, 128) 0 _________________________________________________________________ flatten_4 (Flatten) (None, 6272) 0 _________________________________________________________________ dense_7 (Dense) (None, 512) 3211776 _________________________________________________________________ dense_8 (Dense) (None, 1) 513 ================================================================= Total params: 3,453,121 Trainable params: 3,453,121 Non-trainable params: 0 _________________________________________________________________

在編譯步驟里，使用RMSprop優化器。由于用一個單一的神經元(Sigmoid的激活函數）結束了網絡，將使用二進制交叉熵(binary crossentropy)作為損失函數

from keras import optimizersmodel.compile(loss='binary_crossentropy',optimizer=optimizers.RMSprop(lr=1e-4),metrics=['acc'])

3.資料預處理

網絡的預處理步驟：
讀入圖像

將JPEG內容解碼為RGB網格的像素

將其轉換為浮點張量

將像素值(0和255之間)重新縮放到[0,1]間隔

數據應該先被格式化成適當的預處理浮點張量，然后才能輸入到神經網絡中

from keras.preprocessing.image import ImageDataGenerator # 所有的圖像將重新進行歸一化處理　Rescaled by 1./255 train_datagen = ImageDataGenerator(rescale=1./255) validation_datagen=ImageDataGenerator(rescale=1./255) test_datagen = ImageDataGenerator(rescale=1./255) # 直接從目錄讀取圖像數據 train_generator = train_datagen.flow_from_directory(# 訓練圖像的目錄train_dir,# 所有圖像大小會被轉換成150x150target_size=(150, 150),# 每次產生20個圖像的批次batch_size=20,# 由于這是一個二元分類問題，y的label值也會被轉換成二元的標簽class_mode='binary') # 直接從目錄讀取圖像數據 validation_generator = test_datagen.flow_from_directory(validation_dir,target_size=(150, 150),batch_size=20,class_mode='binary') test_generator = test_datagen.flow_from_directory(test_dir,target_size=(150, 150),batch_size=20,class_mode='binary') Found 600 images belonging to 2 classes. Found 300 images belonging to 2 classes. Found 300 images belonging to 2 classes.

圖像張量生成器(generator)的輸出，它產生150x150 RGB圖像(形狀"(20,150,150,3)")和二進制標簽(形狀"(20,)")的批次張量。20是每個批次中的樣品數(批次大小)

for data_batch, labels_batch in train_generator:print('data batch shape:', data_batch.shape)print('labels batch shape:', labels_batch)break data batch shape: (20, 150, 150, 3) labels batch shape: [ 1. 1. 1. 0. 1. 1. 0. 0. 0. 0. 1. 0. 0. 1. 1. 0. 1. 0.0. 0.]

4.開始訓練

這里取epochs=10，其中epochs值越大，花費的時間就越久、訓練的精度更高，我電腦性能不好，運行了很久… …

#花費時間長 history = model.fit_generator(train_generator,steps_per_epoch=100,epochs=10,validation_data=validation_generator,validation_steps=50) Epoch 1/10 100/100 [==============================] - 218s 2s/step - loss: 0.2563 - acc: 0.8990 - val_loss: 0.1740 - val_acc: 0.9400 Epoch 2/10 100/100 [==============================] - 189s 2s/step - loss: 0.0862 - acc: 0.9700 - val_loss: 0.1294 - val_acc: 0.9540 Epoch 3/10 100/100 [==============================] - 190s 2s/step - loss: 0.0548 - acc: 0.9820 - val_loss: 0.1033 - val_acc: 0.9680 Epoch 4/10 100/100 [==============================] - 186s 2s/step - loss: 0.0325 - acc: 0.9880 - val_loss: 0.1132 - val_acc: 0.9620 Epoch 5/10 100/100 [==============================] - 192s 2s/step - loss: 0.0238 - acc: 0.9925 - val_loss: 0.0922 - val_acc: 0.9800 Epoch 6/10 100/100 [==============================] - 191s 2s/step - loss: 0.0132 - acc: 0.9965 - val_loss: 0.0950 - val_acc: 0.9710 Epoch 7/10 100/100 [==============================] - 189s 2s/step - loss: 0.0061 - acc: 0.9980 - val_loss: 0.1093 - val_acc: 0.9710 Epoch 8/10 100/100 [==============================] - 188s 2s/step - loss: 0.0025 - acc: 0.9995 - val_loss: 0.1305 - val_acc: 0.9690 Epoch 9/10 100/100 [==============================] - 185s 2s/step - loss: 0.0080 - acc: 0.9980 - val_loss: 0.1067 - val_acc: 0.9770 Epoch 10/10 100/100 [==============================] - 189s 2s/step - loss: 6.6883e-04 - acc: 1.0000 - val_loss: 0.1032 - val_acc: 0.9780

訓練完成后把模型保存下來

model.save('maskout/maskAndNomask_1.h5')

使用圖表來繪制在訓練過程中模型對訓練和驗證數據的損失(loss)和準確性(accuracy)數據

import matplotlib.pyplot as plt # import h5pyacc = history.history['acc'] val_acc = history.history['val_acc'] loss = history.history['loss'] val_loss = history.history['val_loss']epochs = range(len(acc)) # print('acc:',acc) # print('val_acc:',val_acc) # print('loss:',loss) # print('val_loss:',val_loss) plt.plot(epochs, acc, 'bo', label='Training acc') plt.plot(epochs, val_acc, 'b', label='Validation acc') plt.title('Training and validation accuracy') plt.legend()plt.figure()plt.plot(epochs, loss, 'bo', label='Training loss') plt.plot(epochs, val_loss, 'b', label='Validation loss') plt.title('Training and validation loss') plt.legend()plt.show()

上面圖標顯示了過度擬合(overfitting)的特征。我們的訓練精確度隨著時間線性增長，直到接近100%,然而我們的驗證精度卻停在96%~97%。
我們的驗證損失在第4個循環(epochs)之后達到最小值，然后停頓，而訓練損失在線性上保持下降直到接近０。

5.使用數據填充

數據增加采用從現有訓練樣本生成更多訓練數據的方法，通過產生可信的圖像的多個隨機變換來"增加"樣本。目標是在訓練的時候，我們的模型永遠不會再看到完全相同的畫面兩次。這有助于模型學習到數據的更多方面，并更好地推廣。

在keras中，可以通過配置對ImageDataGenerator實例讀取的圖像執行多個隨機變換來完成

datagen = ImageDataGenerator(rotation_range=40,width_shift_range=0.2,height_shift_range=0.2,shear_range=0.2,zoom_range=0.2,horizontal_flip=True,fill_mode='nearest')

這里列出一些可用的選項(更多選項，可以參考keras文檔），快速看一下這些參數:
rotation_range 是以度（0-180)為單位的值，它是隨機旋轉圖片的范圍
width_shift 和 height_shift 是范圍(占總寬度或高度的一小部分),用于縱向或橫向隨機轉換圖片
shear_range 用于隨機剪切變換
zoom_range 用于隨機放大圖片內容
horizontal_flip 用于在沒有水平不對稱假設（例如真實世界圖片）的情況下水平地隨機翻轉一半圖像
fill_mode 是用于填充新創建的像素的策略，可以在旋轉或寬/高移位后顯示

看增強后的圖像

import matplotlib.pyplot as plt from keras.preprocessing import image fnames = [os.path.join(train_havemask_dir, fname) for fname in os.listdir(train_havemask_dir)] img_path = fnames[3] img = image.load_img(img_path, target_size=(150, 150)) x = image.img_to_array(img) x = x.reshape((1,) + x.shape) i = 0 for batch in datagen.flow(x, batch_size=1):plt.figure(i)imgplot = plt.imshow(image.array_to_img(batch[0]))i += 1if i % 4 == 0:break plt.show()

如果我們使用這種數據增強配置來訓練一個新的網絡，我們的網絡將永遠不會看到相同重復的輸入。

然而，它看到的輸入仍然是相互關聯的，因為它們來自少量的原始圖像 - 我們不能產生新的信息，我們只能重新混合現有的信息。
因此，這可能不足以完全擺脫過度擬合(overfitting)。為了進一步克服過度擬合(overfitting)，我們還將在密集連接(densely-connected)的分類器之前添加一個Dropout層。

model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu',input_shape=(150, 150, 3))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dropout(0.5)) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(1, activation='sigmoid'))model.compile(loss='binary_crossentropy',optimizer=optimizers.RMSprop(lr=1e-4),metrics=['acc'])

使用數據填充(data augmentation)和dropout來訓練我們的網絡

#歸一化處理 train_datagen = ImageDataGenerator(rescale=1./255,rotation_range=40,width_shift_range=0.2,height_shift_range=0.2,shear_range=0.2,zoom_range=0.2,horizontal_flip=True,)# Note that the validation data should not be augmented! test_datagen = ImageDataGenerator(rescale=1./255)train_generator = train_datagen.flow_from_directory(# This is the target directorytrain_dir,# All images will be resized to 150x150target_size=(150, 150),batch_size=32,# Since we use binary_crossentropy loss, we need binary labelsclass_mode='binary')validation_generator = test_datagen.flow_from_directory(validation_dir,target_size=(150, 150),batch_size=32,class_mode='binary')history = model.fit_generator(train_generator,steps_per_epoch=100,epochs=60, validation_data=validation_generator,validation_steps=50) Found 600 images belonging to 2 classes. Found 300 images belonging to 2 classes. Epoch 1/60 100/100 [==============================] - 351s 4s/step - loss: 0.4850 - acc: 0.7632 - val_loss: 0.2380 - val_acc: 0.8900 Epoch 2/60 100/100 [==============================] - 323s 3s/step - loss: 0.3041 - acc: 0.8703 - val_loss: 0.2513 - val_acc: 0.8833 Epoch 3/60 100/100 [==============================] - 322s 3s/step - loss: 0.2864 - acc: 0.8725 - val_loss: 0.2486 - val_acc: 0.8867 Epoch 4/60 100/100 [==============================] - 316s 3s/step - loss: 0.2490 - acc: 0.8964 - val_loss: 0.1243 - val_acc: 0.9533 Epoch 5/60 100/100 [==============================] - 308s 3s/step - loss: 0.2303 - acc: 0.9056 - val_loss: 0.1830 - val_acc: 0.9200 Epoch 6/60 100/100 [==============================] - 306s 3s/step - loss: 0.2098 - acc: 0.9152 - val_loss: 0.1101 - val_acc: 0.9633 Epoch 7/60 100/100 [==============================] - 312s 3s/step - loss: 0.1905 - acc: 0.9200 - val_loss: 0.1417 - val_acc: 0.9367 Epoch 8/60 100/100 [==============================] - 310s 3s/step - loss: 0.1771 - acc: 0.9272 - val_loss: 0.1021 - val_acc: 0.9700 Epoch 9/60 100/100 [==============================] - 302s 3s/step - loss: 0.1710 - acc: 0.9284 - val_loss: 0.1220 - val_acc: 0.9467 Epoch 10/60 100/100 [==============================] - 321s 3s/step - loss: 0.1618 - acc: 0.9375 - val_loss: 0.0920 - val_acc: 0.9667 Epoch 11/60 100/100 [==============================] - 308s 3s/step - loss: 0.1458 - acc: 0.9420 - val_loss: 0.2019 - val_acc: 0.9167 Epoch 12/60 100/100 [==============================] - 303s 3s/step - loss: 0.1411 - acc: 0.9456 - val_loss: 0.0829 - val_acc: 0.9700 Epoch 13/60 100/100 [==============================] - 304s 3s/step - loss: 0.1190 - acc: 0.9537 - val_loss: 0.0932 - val_acc: 0.9667 Epoch 14/60 100/100 [==============================] - 307s 3s/step - loss: 0.1163 - acc: 0.9569 - val_loss: 0.1085 - val_acc: 0.9567 Epoch 15/60 100/100 [==============================] - 306s 3s/step - loss: 0.1006 - acc: 0.9629 - val_loss: 0.0715 - val_acc: 0.9767 Epoch 16/60 100/100 [==============================] - 312s 3s/step - loss: 0.0960 - acc: 0.9667 - val_loss: 0.0588 - val_acc: 0.9767 Epoch 17/60 100/100 [==============================] - 308s 3s/step - loss: 0.0806 - acc: 0.9676 - val_loss: 0.0535 - val_acc: 0.9800 Epoch 18/60 100/100 [==============================] - 305s 3s/step - loss: 0.0778 - acc: 0.9711 - val_loss: 0.2239 - val_acc: 0.9300 Epoch 19/60 100/100 [==============================] - 307s 3s/step - loss: 0.0761 - acc: 0.9713 - val_loss: 0.0575 - val_acc: 0.9767 Epoch 20/60 100/100 [==============================] - 308s 3s/step - loss: 0.0507 - acc: 0.9816 - val_loss: 0.0926 - val_acc: 0.9667 Epoch 21/60 100/100 [==============================] - 306s 3s/step - loss: 0.0635 - acc: 0.9799 - val_loss: 0.0470 - val_acc: 0.9833 Epoch 22/60 100/100 [==============================] - 319s 3s/step - loss: 0.0701 - acc: 0.9750 - val_loss: 0.0437 - val_acc: 0.9867 Epoch 23/60 100/100 [==============================] - 315s 3s/step - loss: 0.0493 - acc: 0.9849 - val_loss: 0.0408 - val_acc: 0.9900 Epoch 24/60 100/100 [==============================] - 309s 3s/step - loss: 0.0513 - acc: 0.9824 - val_loss: 0.0449 - val_acc: 0.9767 Epoch 25/60 100/100 [==============================] - 304s 3s/step - loss: 0.0580 - acc: 0.9816 - val_loss: 0.0330 - val_acc: 0.9900 Epoch 26/60 100/100 [==============================] - 312s 3s/step - loss: 0.0434 - acc: 0.9884 - val_loss: 0.0357 - val_acc: 0.9833 Epoch 27/60 100/100 [==============================] - 302s 3s/step - loss: 0.0707 - acc: 0.9785 - val_loss: 0.0214 - val_acc: 0.9933 Epoch 28/60 100/100 [==============================] - 311s 3s/step - loss: 0.0431 - acc: 0.9869 - val_loss: 0.0306 - val_acc: 0.9900 Epoch 29/60 100/100 [==============================] - 305s 3s/step - loss: 0.0424 - acc: 0.9859 - val_loss: 0.0278 - val_acc: 0.9900 Epoch 30/60 100/100 [==============================] - 305s 3s/step - loss: 0.0240 - acc: 0.9934 - val_loss: 0.0233 - val_acc: 0.9933 Epoch 31/60 100/100 [==============================] - 335s 3s/step - loss: 0.0515 - acc: 0.9853 - val_loss: 0.0268 - val_acc: 0.9867 Epoch 32/60 100/100 [==============================] - 326s 3s/step - loss: 0.0515 - acc: 0.9884 - val_loss: 0.0222 - val_acc: 0.9933 Epoch 33/60 100/100 [==============================] - 320s 3s/step - loss: 0.0273 - acc: 0.9927 - val_loss: 0.0281 - val_acc: 0.9900 Epoch 34/60 100/100 [==============================] - 310s 3s/step - loss: 0.0411 - acc: 0.9909 - val_loss: 0.0282 - val_acc: 0.9900 Epoch 35/60 100/100 [==============================] - 306s 3s/step - loss: 0.0204 - acc: 0.9950 - val_loss: 0.0165 - val_acc: 0.9933 Epoch 36/60 100/100 [==============================] - 306s 3s/step - loss: 0.0623 - acc: 0.9842 - val_loss: 0.0268 - val_acc: 0.9900 Epoch 37/60 100/100 [==============================] - 304s 3s/step - loss: 0.0325 - acc: 0.9908 - val_loss: 0.0152 - val_acc: 0.9933 Epoch 38/60 100/100 [==============================] - 305s 3s/step - loss: 0.0178 - acc: 0.9933 - val_loss: 0.0117 - val_acc: 0.9967 Epoch 39/60 100/100 [==============================] - 309s 3s/step - loss: 0.0507 - acc: 0.9884 - val_loss: 0.0164 - val_acc: 0.9933 Epoch 40/60 100/100 [==============================] - 305s 3s/step - loss: 0.0398 - acc: 0.9919 - val_loss: 0.0236 - val_acc: 0.9933 Epoch 41/60 100/100 [==============================] - 300s 3s/step - loss: 0.0243 - acc: 0.9909 - val_loss: 0.0176 - val_acc: 0.9933 Epoch 42/60 100/100 [==============================] - 307s 3s/step - loss: 0.0419 - acc: 0.9922 - val_loss: 0.0145 - val_acc: 0.9933 Epoch 43/60 100/100 [==============================] - 302s 3s/step - loss: 0.0451 - acc: 0.9928 - val_loss: 0.0155 - val_acc: 0.9933 Epoch 44/60 100/100 [==============================] - 304s 3s/step - loss: 0.0640 - acc: 0.9893 - val_loss: 0.2175 - val_acc: 0.9333 Epoch 45/60 100/100 [==============================] - 314s 3s/step - loss: 0.0285 - acc: 0.9934 - val_loss: 0.0092 - val_acc: 0.9967 Epoch 46/60 100/100 [==============================] - 309s 3s/step - loss: 0.0279 - acc: 0.9937 - val_loss: 0.0116 - val_acc: 0.9933 Epoch 47/60 100/100 [==============================] - 305s 3s/step - loss: 0.0258 - acc: 0.9925 - val_loss: 0.0157 - val_acc: 0.9900 Epoch 48/60 100/100 [==============================] - 307s 3s/step - loss: 0.0319 - acc: 0.9906 - val_loss: 0.0142 - val_acc: 0.9933 Epoch 49/60 100/100 [==============================] - 305s 3s/step - loss: 0.0562 - acc: 0.9884 - val_loss: 0.0228 - val_acc: 0.9933 Epoch 50/60 100/100 [==============================] - 305s 3s/step - loss: 0.0370 - acc: 0.9931 - val_loss: 0.0230 - val_acc: 0.9867 Epoch 51/60 100/100 [==============================] - 309s 3s/step - loss: 0.0047 - acc: 0.9984 - val_loss: 0.0147 - val_acc: 0.9933 Epoch 52/60 100/100 [==============================] - 306s 3s/step - loss: 0.0237 - acc: 0.9941 - val_loss: 0.0161 - val_acc: 0.9900 Epoch 53/60 100/100 [==============================] - 301s 3s/step - loss: 0.0278 - acc: 0.9950 - val_loss: 0.0202 - val_acc: 0.9933 Epoch 54/60 100/100 [==============================] - 309s 3s/step - loss: 0.0266 - acc: 0.9945 - val_loss: 0.0267 - val_acc: 0.9933 Epoch 55/60 100/100 [==============================] - 302s 3s/step - loss: 0.0264 - acc: 0.9941 - val_loss: 0.0231 - val_acc: 0.9967 Epoch 56/60 100/100 [==============================] - 304s 3s/step - loss: 0.0132 - acc: 0.9959 - val_loss: 0.0177 - val_acc: 0.9933 Epoch 57/60 100/100 [==============================] - 326s 3s/step - loss: 0.0773 - acc: 0.9891 - val_loss: 0.0893 - val_acc: 0.9733 Epoch 58/60 100/100 [==============================] - 311s 3s/step - loss: 0.0049 - acc: 0.9984 - val_loss: 0.0277 - val_acc: 0.9933 Epoch 59/60 100/100 [==============================] - 308s 3s/step - loss: 0.0791 - acc: 0.9906 - val_loss: 0.0314 - val_acc: 0.9867 Epoch 60/60 100/100 [==============================] - 307s 3s/step - loss: 0.0133 - acc: 0.9956 - val_loss: 0.0186 - val_acc: 0.9933

查看0與1代表含義（0代表有口罩、1代表沒有口罩）

train_generator.class_indices {'have_mask': 0, 'no_mask': 1}

保存訓練模型

#保存模型 model.save('maskout/maskAndNomask_2.h5')

保存模型后的文件夾顯示效果
繪制數據增強后的訓練集與驗證集的精確度與損失度的圖形，看一遍結果

由于數據增加(data augmentation)和dropout使用，不再有過度擬合(overfitting)的問題。

訓練曲線相當密切地跟隨著驗證曲線。訓練精度和驗證精度經過60個循環無限接近100%。
驗證損失和訓練損失在線性上保持下降直到接近０。

通過進一步利用正規化技術，及調整網絡參數(例如每個卷積層的濾波器數量或網絡層數)，可以獲得更好的準確度。

總結體會：可以看出，采用卷積神經網絡（CNN）對人臉微笑識別和口罩識別出來的準確的還是蠻高的。由于寒假忘記帶電腦回家（沒想到有疫情），用家里面的電腦運行性能不太好，所有導致我訓練時花了很多時間，但我一般都是晚上訓練，第二天早上起來一般就會有結果了。

6.對人臉戴口罩與否的模型訓練

判斷的第一張圖片（D:/mango/nana.jpg路徑下）

我喜歡的明星 Nana

from keras.preprocessing import image from keras.models import load_model import numpy as npmodel = load_model('maskout/maskAndNomask_1.h5')img_path='D:/mango/nana.jpg'img = image.load_img(img_path, target_size=(150, 150)) #print(img.size) img_tensor = image.img_to_array(img)/255.0 img_tensor = np.expand_dims(img_tensor, axis=0) prediction =model.predict(img_tensor) print(prediction) if prediction[0][0]>0.5:result='未戴口罩' else:result='戴口罩' print(result) [[ 0.0132275]] 戴口罩

判斷的第二張圖片（D:/mango/mengmeng.jpg路徑下）

（這也是她自己拍的，哈哈… …）

# 單張圖片進行判斷是否戴口罩 from keras.preprocessing import image from keras.models import load_model import numpy as npmodel = load_model('maskout/maskAndNomask_2.h5')img_path='D:/mango/mengmeng.jpg'img = image.load_img(img_path, target_size=(150, 150)) #print(img.size) img_tensor = image.img_to_array(img)/255.0 img_tensor = np.expand_dims(img_tensor, axis=0) prediction =model.predict(img_tensor) print(prediction) if prediction[0][0]>0.5:result='未戴口罩' else:result='戴口罩' print(result) [[ 0.99999881]] 未戴口罩

可以看見，判斷圖片是否戴口罩準確度還是很高的，但是還是有一定得誤差。
綜上所述，圖片中人臉越清晰越容易判別正確的精度就越高。

四、完成一個攝像頭采集自己人臉、并對表情（笑臉/非笑臉、戴口罩和沒戴口罩）的實時分類判讀（輸出分類文字）的程序

1.笑臉/非笑臉實時分類判讀（輸出分類文字）的程序

#檢測視頻或者攝像頭中的人臉 import cv2 from keras.preprocessing import image from keras.models import load_model import numpy as np import dlib from PIL import Image model = load_model('mangoout/smileAndUnsmile_2.h5') detector = dlib.get_frontal_face_detector() video=cv2.VideoCapture(0) font = cv2.FONT_HERSHEY_SIMPLEX def rec(img):gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)dets=detector(gray,1)if dets is not None:for face in dets:left=face.left()top=face.top()right=face.right()bottom=face.bottom()cv2.rectangle(img,(left,top),(right,bottom),(0,255,0),2)img1=cv2.resize(img[top:bottom,left:right],dsize=(150,150))img1=cv2.cvtColor(img1,cv2.COLOR_BGR2RGB)img1 = np.array(img1)/255.img_tensor = img1.reshape(-1,150,150,3)prediction =model.predict(img_tensor) if prediction[0][0]>0.5:result='unsmile'else:result='smile'cv2.putText(img, result, (left,top), font, 2, (0, 255, 0), 2, cv2.LINE_AA)cv2.imshow('Video', img) while video.isOpened():res, img_rd = video.read()if not res:breakrec(img_rd)if cv2.waitKey(1) & 0xFF == ord('q'):break video.release() cv2.destroyAllWindows()

識別自己的圖片運行效果:

沒有微笑

微笑

2.戴口罩和沒戴口罩的實時分類判讀（輸出分類文字）的程序

import cv2 from keras.preprocessing import image from keras.models import load_model import numpy as np import dlib from PIL import Image model = load_model('maskout/maskAndNomask_2.h5') detector = dlib.get_frontal_face_detector() # video=cv2.VideoCapture('media/video.mp4') # video=cv2.VideoCapture('data/face_recognition.mp4') video=cv2.VideoCapture(0) font = cv2.FONT_HERSHEY_SIMPLEX def rec(img):gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)dets=detector(gray,1)if dets is not None:for face in dets:left=face.left()top=face.top()right=face.right()bottom=face.bottom()cv2.rectangle(img,(left,top),(right,bottom),(0,255,255),2) def mask(img):img1=cv2.resize(img,dsize=(150,150))img1=cv2.cvtColor(img1,cv2.COLOR_BGR2RGB)img1 = np.array(img1)/255.img_tensor = img1.reshape(-1,150,150,3)prediction =model.predict(img_tensor) if prediction[0][0]>0.5:result='no-mask'else:result='have-mask'cv2.putText(img, result, (100,200), font, 2, (255, 255, 100), 2, cv2.LINE_AA)cv2.imshow('Video', img) while video.isOpened():res, img_rd = video.read()if not res:break#將視頻每一幀傳入兩個函數，分別用于圈出人臉與判斷是否帶口罩rec(img_rd)mask(img_rd)#q關閉窗口if cv2.waitKey(1) & 0xFF == ord('q'):break video.release() cv2.destroyAllWindows()

運行結果：

沒有戴口罩的效果

戴口罩的效果

這次的關于用Python編碼，利用卷積神經網路（CNN）實現的笑臉識別和口罩識別到這里就結束了。這次把自己圖片也用上了，主要是想讓自己寫的博客盡量有意義一點（平時生活中拍照還是用美圖好一點，人丑勿怪，哈哈… …）。
🌱
更多的還是希望自己的博客可以對一些剛開始接觸這個的小萌新有所幫助。

最后，作為物聯網小白，如果能夠得到大佬們的指點當然是很開心的，加油！

總結

以上是生活随笔為你收集整理的【人工智能与机器学习】——Keras编程分别实现人脸微笑和口罩数据集的识别模型训练和测试（卷积神经网络CNN） + 实时分类微笑和口罩识别检测的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：万花尺matlab仿真（圆内旋轮线，异形
下一篇：人工智能设计------------意识