devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

人脸识别 openCV+tensorflow_tensorflow训练opencv人脸模型

作者：笔触狂放9 | 2024-04-04 18:48:46

赞

踩

tensorflow训练opencv人脸模型

环境

win10，jupyter notebook，python3.7，tensorflow2，cpu

sklearn datasets数据集

先用一个sklearn自带的数据集做一个简单的人脸识别测试。

  1. from sklearn import datasets
  2. from matplotlib import pyplot as plt
  3. import  tensorflow.keras as keras
  4. import numpy as np
  5. faces = datasets.fetch_olivetti_faces()
  6. print(faces.images.shape)
  7.  
  8. i = 0
  9. plt.figure(figsize=(20, 20))
  10. for img in faces.images:
  11.     #总共400张图，把图像分割成20X20
  12.     plt.subplot(20, 20, i+1)
  13.     plt.imshow(img, cmap="gray")
  14.     #关闭x，y轴显示
  15.     plt.xticks([])
  16.     plt.yticks([])
  17.     plt.xlabel(faces.target[i])
  18.     i = i + 1
  19. plt.show()
  20. #人脸数据
  21. X = faces.images
  22. #人脸对应的标签
  23. y = faces.target
  24. print(X[0])
  25. print(y[0])
  26. X = X.reshape(400, 64, 64, 1)
  27. from sklearn.model_selection import train_test_split
  28. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
  29.  
  30. model = keras.Sequential()
  31. # 第一层卷积，卷积的数量为128，卷积的高和宽是3x3，激活函数使用relu
  32. model.add(keras.layers.Conv2D(128, kernel_size=3, activation='relu', input_shape=(64, 64, 1)))
  33. # 第二层卷积
  34. model.add(keras.layers.Conv2D(64, kernel_size=3, activation='relu'))
  35. #把多维数组压缩成一维，里面的操作可以简单理解为reshape，方便后面Dense使用
  36. model.add(keras.layers.Flatten())
  37. #对应cnn的全链接层，可以简单理解为把上面的小图汇集起来，进行分类
  38. model.add(keras.layers.Dense(40, activation='softmax'))
  39. model.compile(optimizer='adam',
  40.               loss='sparse_categorical_crossentropy',
  41.               metrics=['accuracy'])
  42.  
  43. model.fit(X_train, y_train, epochs=10)
  44.  
  45. y_predict = model.predict(X_test)
  46. print(y_test[0], np.argmax(y_predict[0]))

ok。下面我们利用openCV和tensorflow建立自己的人脸识别模型

openCV+tensorflow人脸识别模型

导入模块

  1. import cv2
  2. import sys
  3. import os
  4. import numpy as np
  5. import random
  6.  
  7. import tensorflow as tf
  8. from tensorflow.keras.layers import Dense, Flatten, Conv2D
  9. from tensorflow.keras import Model
  10. from sklearn.model_selection import train_test_split
  11. from keras import backend as K
  12. from PIL import Image, ImageDraw, ImageFont
  13. from __future__ import absolute_import, division, print_function, unicode_literals

捕捉图像

该步骤使用openCV捕捉摄像头或视频，按帧数取图片，每个标签取200帧。

摄像头和视频地址设置见注释，需要注意的是级联分类器的地址需改为自己的openCV 库安装位置

  1. def CatchPICFromVideo(window_name, camera_idx, catch_pic_num, path_name):
  2.     cv2.namedWindow(window_name)
  3.     #设置视频来源，0为摄像头，“视频地址，如C:/Users/lishu/Desktop/ob/x/face/zjm/zjm.mp4”
  4.     cap = cv2.VideoCapture(0)
  5.     #openCV级联分类器地址:openCV库安装地址找haarcascade_frontalface_alt2.xml文件
  6.     classfier = cv2.CascadeClassifier("C:/Users/lishu/Anaconda3/Lib/site-packages/cv2/data/haarcascade_frontalface_alt2.xml")
  7.     color = (255, 0, 0)
  8.     num = 0
  9.     while cap.isOpened():
  10.         ok, frame = cap.read()#frame是读取的图像，三阶矩阵
  11.         if not ok:
  12.             break
  13.         grey = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
  14.         faceRects = classfier.detectMultiScale(grey, scaleFactor = 1.2, minNeighbors = 3, minSize = (32, 32))
  15.         if len(faceRects) > 0:
  16.             for faceRect in faceRects:
  17.                 x, y, w, h = faceRect
  18.                 img_name = '%s%d.jpg'%(path_name, num)#保存当前帧为图片
  19.                 image = frame[y - 10: y + h + 10, x - 10: x + w + 10]
  20.                 cv2.imwrite(img_name, image)
  21.                 num += 1
  22.                 if num > (catch_pic_num):
  23.                     break
  24.                 cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, 2)
  25.                 font = cv2.FONT_HERSHEY_SIMPLEX
  26.                 cv2.putText(frame, 'num:%d' % (num), (30, 30), font, 1, (255, 0, 0), 1)
  27.         if num > (catch_pic_num):break
  28.         cv2.imshow(window_name, frame)
  29.         c = cv2.waitKey(10)
  30.         if c & 0xFF == ord('q'):
  31.             break
  32.     cap.release()
  33.     cv2.destroyAllWindows()
  34. if __name__ == '__main__':
  35.     CatchPICFromVideo("catch_face_data", 0, 200-1, 'C:/Users/lishu/Desktop/ob/xx/face/axe/axe')

数据预处理

  1. IMAGE_SIZE = 64     #将图片大小设置为64*64
  2.  
  3. #按照指定图像大小调整尺寸
  4. def resize_image(image, height = IMAGE_SIZE, width = IMAGE_SIZE):
  5.     top, bottom, left, right = (0, 0, 0, 0)
  6.     
  7.     #获取图像尺寸
  8.     h, w, _ = image.shape
  9.     
  10.     #对于长宽不相等的图片，找到最长的一边
  11.     longest_edge = max(h, w)    
  12.     
  13.     #计算短边需要增加多少像素宽度使其与长边等长
  14.     if h < longest_edge:
  15.         dh = longest_edge - h
  16.         top = dh // 2
  17.         bottom = dh - top
  18.     elif w < longest_edge:
  19.         dw = longest_edge - w
  20.         left = dw // 2
  21.         right = dw - left
  22.     else:
  23.         pass 
  24.     
  25.     #RGB颜色
  26.     BLACK = [0, 0, 0]
  27.     
  28.     #给图像增加边界，是图片长、宽等长，cv2.BORDER_CONSTANT指定边界颜色由value指定
  29.     constant = cv2.copyMakeBorder(image, top , bottom, left, right, cv2.BORDER_CONSTANT, value = BLACK)
  30.     #将图像设置为灰度图
  31.     constant = cv2.cvtColor(constant,cv2.COLOR_BGR2GRAY)
  32.  
  33.     #调整图像大小并返回
  34.     return cv2.resize(constant, (height, width))
  35.  
  36. def read_path(path_name):    
  37.     for dir_item in os.listdir(path_name):
  38.         #从初始路径开始叠加，合并成可识别的操作路径
  39.         full_path = os.path.abspath(os.path.join(path_name, dir_item))
  40.         
  41.         if os.path.isdir(full_path):    #如果是文件夹，继续递归调用
  42.             read_path(full_path)
  43.         else:   #文件
  44.             if dir_item.endswith('.jpg'):
  45.                 image = cv2.imread(full_path)                
  46.                 image = resize_image(image, IMAGE_SIZE, IMAGE_SIZE)
  47.                 
  48.                 
  49.                 images.append(image)                
  50.                 labels.append(path_name)                                
  51.                     
  52.     return images,labels
  53.     
  54.  
  55. #从指定路径读取训练数据
  56. def load_dataset(path_name):
  57.     images,labels = read_path(path_name)    
  58.     
  59.     #将输入的所有图片转成四维数组，尺寸为(图片数量*IMAGE_SIZE*IMAGE_SIZE*3)
  60.     #尺寸为 200*5* 64 * 64 * 3 
  61.     #5个人 每个人200张 图片为64 * 64像素,一个像素3个颜色值(RGB)
  62.     images = np.array(images)
  63.     print(images.shape)    
  64.     
  65.     #标注数据（采用onehot编码），分别不同指定标签（请注意必须从0开始算标签）
  66.     temp=0
  67.     for label in labels :
  68.         if label.endswith('axe') :  
  69.             labels[temp]=0
  70.         elif label.endswith('ef') :
  71.             labels[temp]=1           
  72.            
  73.         temp=temp+1
  74.     return images, labels

训练模型

adam优化器参数learning_rate根据经验设置为0.001，

batch设置为2的幂次，数值越大，收敛越快，但单次迭代时间越长。

epoch参数，设置学习轮数，根据训练准确度来设置，这里设置为100，不宜过大，防止过拟合。

  1. class Dataset:
  2.     def __init__(self, path_name):
  3.         #训练集
  4.         self.train_images = None
  5.         self.train_labels = None
  6.         
  7.         
  8.         #测试集
  9.         self.test_images  = None            
  10.         self.test_labels  = None
  11.         
  12.         #数据集加载路径
  13.         self.path_name    = path_name
  14.         
  15.         #当前库采用的维度顺序
  16.         self.input_shape = None
  17.  
  18.         self.nb_classes=None
  19.  
  20.         
  21.     #加载数据集并按照交叉验证的原则划分数据集并进行相关预处理工作
  22.     def load(self, img_rows = IMAGE_SIZE, img_cols = IMAGE_SIZE, 
  23.              img_channels = 1, nb_classes = 5): #灰度图所以通道数为1-5个类别 所以分组数为5
  24.         #加载数据集到内存
  25.         images, labels = load_dataset(self.path_name)        
  26.         
  27.         train_images, test_images, train_labels, test_labels = train_test_split(images, labels, test_size = 0.3, random_state = random.randint(0, 100))   #将总数据按0.3比重随机分配给训练集和测试集    
  28.         
  29.  
  30.         train_images = train_images.reshape(train_images.shape[0], img_rows, img_cols, img_channels) #由于TensorFlow需要通道数，我们上一步设置为灰度图，所以这里为1，否则彩色图为3
  31.         test_images = test_images.reshape(test_images.shape[0], img_rows, img_cols, img_channels)
  32.         self.input_shape = (img_rows, img_cols, img_channels)            
  33.         
  34.         #输出训练集、测试集的数量
  35.         print(train_images.shape[0], 'train samples')
  36.         print(test_images.shape[0], 'test samples')
  37.                         
  38.     
  39.         #像素数据浮点化以便归一化
  40.         train_images = train_images.astype('float32')            
  41.         test_images = test_images.astype('float32')
  42.         
  43.         #将其归一化,图像的各像素值归一化到0~1区间
  44.         train_images /= 255
  45.         test_images /= 255
  46.  
  47.  
  48.  
  49.         self.train_images = train_images
  50.         self.test_images  = test_images
  51.         self.train_labels = train_labels
  52.         self.test_labels  = test_labels
  53.         self.nb_classes   = nb_classes
  54.  
  55.  
  56.  
  57.  
  58.  #建立CNN模型
  59. class CNN(tf.keras.Model):
  60.     #模型初始化
  61.     def __init__(self):
  62.         super().__init__()
  63.         self.conv1 = tf.keras.layers.Conv2D(
  64.             filters=32,             # 卷积层神经元（卷积核）数目
  65.             kernel_size=[3, 3],     # 感受野大小
  66.             padding='same',         # padding策略（vaild 或 same）
  67.             activation=tf.nn.relu,   # 激活函数
  68.         )
  69.  
  70.         self.conv3=tf.keras.layers.Conv2D( filters=32, kernel_size=[3, 3],  activation=tf.nn.relu )
  71.         self.pool3 = tf.keras.layers.MaxPool2D(pool_size=[2, 2])
  72.         self.conv4=tf.keras.layers.Conv2D( filters=64, kernel_size=[3, 3], padding='same',  activation=tf.nn.relu )
  73.         self.conv5=tf.keras.layers.Conv2D( filters=64, kernel_size=[3, 3],  activation=tf.nn.relu )
  74.         self.pool4 = tf.keras.layers.MaxPool2D(pool_size=[2, 2])
  75.         self.flaten1=tf.keras.layers.Flatten()
  76.         self.dense3 = tf.keras.layers.Dense(units=512,activation=tf.nn.relu)
  77.         self.dense4 = tf.keras.layers.Dense(units=5) #最后分类 5个单位
  78.         
  79.         
  80.     #模型输出
  81.     def call(self, inputs):
  82.         x = self.conv1(inputs)                  
  83.         x = self.conv3(x)
  84.         x = self.pool3(x)
  85.         x = self.conv4(x)
  86.         x = self.conv5(x)
  87.         x = self.pool4(x)
  88.         x = self.flaten1(x)
  89.         x = self.dense3(x)
  90.         x = self.dense4(x)
  91.         output = tf.nn.softmax(x)
  92.         return output 
  93.  
  94.  
  95.     #识别人脸
  96.     def face_predict(self, image):    
  97.  
  98.         image = resize_image(image)
  99.         image = image.reshape((1, IMAGE_SIZE, IMAGE_SIZE, 1))                    
  100.         
  101.         #浮点并归一化
  102.         image = image.astype('float32')
  103.         image /= 255
  104.         
  105.         #给出输入属于各个类别的概率
  106.         result = self.predict(image)
  107.         #print('result:',result[0])
  108.                
  109.         #返回类别预测结果
  110.         return result[0] 
  1. if __name__ == '__main__':
  2.  
  3.     learning_rate = 0.001 #学习率
  4.     batch = 32    #batch数
  5.     EPOCHS = 200   #学习轮数
  6.  
  7.     dataset = Dataset('./face/')    #数据都保存在这个文件夹下
  8.     images = []
  9.     labels = []
  10.     dataset.load()
  11.     
  12.     model = CNN()#模型初始化
  13.     optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate) #选择优化器
  14.     loss_object = tf.keras.losses.SparseCategoricalCrossentropy() #选择损失函数
  15.     train_loss = tf.keras.metrics.Mean(name='train_loss') #设置变量保存训练集的损失值
  16.     train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')#设置变量保存训练集的准确值
  17.     test_loss = tf.keras.metrics.Mean(name='test_loss')#设置变量保存测试集的损失值
  18.     test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')#设置变量保存测试集的准确值
  19.  
  20.  
  21.     @tf.function
  22.     def train_step(images, labels):
  23.       with tf.GradientTape() as tape:
  24.         predictions = model(images)
  25.         loss = loss_object(labels, predictions)
  26.       gradients = tape.gradient(loss, model.trainable_variables)
  27.       optimizer.apply_gradients(zip(gradients, model.trainable_variables))#优化器更新数据
  28.  
  29.       train_loss(loss)#更新损失值
  30.       train_accuracy(labels, predictions)#更新准确值
  31.  
  32.     @tf.function
  33.     def test_step(images, labels):
  34.       predictions = model(images)
  35.       t_loss = loss_object(labels, predictions)
  36.  
  37.       test_loss(t_loss)
  38.       test_accuracy(labels, predictions)
  39.  
  40.  
  41.  
  42.  
  43.     for epoch in range(EPOCHS):
  44.  
  45.       train_ds = tf.data.Dataset.from_tensor_slices((dataset.train_images, dataset.train_labels)).shuffle(300).batch(batch)
  46.       test_ds = tf.data.Dataset.from_tensor_slices((dataset.test_images, dataset.test_labels)).shuffle(300).batch(batch)
  47.     
  48.       for images, labels in train_ds:
  49.         train_step(images, labels)
  50.  
  51.       for test_images, test_labels in test_ds:
  52.         test_step(test_images, test_labels)
  53.  
  54.  
  55.       
  56.       template = 'Epoch {} \nTrain Loss:{:.2f},Train Accuracy:{:.2%}\nTest Loss :{:.2f},Test Accuracy :{:.2%}'
  57.       print (template.format(epoch+1,train_loss.result(),train_accuracy.result(),test_loss.result(),test_accuracy.result()))    #打印
  58.  
  59.     model.save_weights('./model/face') #保存权重模型 命名为face

测试模型

使用摄像头检测人脸，如检测视频中的人脸，改变cap = cv2.VideoCapture()参数，（）中添加视频地址。

按q键退出检测窗口。

  1. if __name__ == '__main__':
  2.         
  3.     #加载模型
  4.     model = CNN()
  5.     model.load_weights('./model/face')    #读取模型权重参数
  6.               
  7.     #框住人脸的矩形边框颜色       
  8.     color = (0, 255, 255)
  9.     
  10.     #捕获指定摄像头的实时视频流
  11.     cap = cv2.VideoCapture(0)
  12.     
  13.     #人脸识别分类器本地存储路径
  14.     cascade_path ="C:/Users/lishu/Anaconda3/Lib/site-packages/cv2/data/haarcascade_frontalface_alt2.xml"    
  15.     
  16.     #循环检测识别人脸
  17.     while True:
  18.         ret, frame = cap.read()   #读取一帧视频
  19.         
  20.         if ret is True:
  21.             
  22.             #图像灰化，降低计算复杂度
  23.             frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
  24.         else:
  25.             continue
  26.         #使用人脸识别分类器，读入分类器
  27.         cascade = cv2.CascadeClassifier(cascade_path)                
  28.  
  29.         #利用分类器识别出哪个区域为人脸
  30.         faceRects = cascade.detectMultiScale(frame_gray, scaleFactor = 1.2, minNeighbors = 3, minSize = (32, 32))        
  31.         if len(faceRects) > 0:                 
  32.             for faceRect in faceRects: 
  33.                 x, y, w, h = faceRect
  34.                 
  35.                 #截取脸部图像提交给模型识别这是谁
  36.                 image = frame[y - 10: y + h + 10, x - 10: x + w + 10]
  37.                 face_probe = model.face_predict(image)   #获得预测值
  38.                 cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, thickness = 2)
  39.                 frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # cv2和PIL中颜色的hex码的储存顺序不同
  40.                 pilimg = Image.fromarray(frame)
  41.                 draw = ImageDraw.Draw(pilimg) # 图片上打印出所有人的预测值
  42.                 font = ImageFont.truetype("simkai.ttf", 20, encoding="utf-8") # 参数1：字体文件路径，参数2：字体大小q
  43. #                 draw.text((x+25,y-95), 'axe:{:.2%}'.format(face_probe[0]), (0, 255, 0), font=font)
  44. #                 draw.text((x+25,y-70), 'ef:{:.2%}'.format(face_probe[1]), (0, 0, 255), font=font)
  45.                 
  46.                 if face_probe[0] > 0.7:
  47.                     draw.text((x+25,y-75), 'axe:{:.2%}'.format(face_probe[0]), (0, 0, 255), font=font)
  48.                 elif face_probe[1] > 0.7:
  49.                     draw.text((x+25,y-75), 'ef:{:.2%}'.format(face_probe[1]), (0, 255, 0), font=font)
  50.                 else:
  51.                     draw.text((x+25, y-75), 'stranger',(255, 0, 0), font=font)
  52.                     
  53.                 frame = cv2.cvtColor(np.array(pilimg), cv2.COLOR_RGB2BGR)
  54.                 
  55.         cv2.imshow("ShowTime", frame)
  56.         
  57.         #等待10毫秒看是否有按键输入
  58.         k = cv2.waitKey(10)
  59.         #如果输入q则退出循环
  60.         if k & 0xFF == ord('q'):
  61.             break
  62.  
  63.     #释放摄像头并销毁所有窗口
  64.     cap.release()
  65.     cv2.destroyAllWindows()
  66.

注

对if __name__ == '__main__':的解释，作为脚本时会执行，如果作为模块加载到其他脚本不会执行。

本文使用jupyter notebook执行代码。

捕捉图像模块，建议捕捉两人以上人脸，否则容易过拟合。在face文件夹下建立人脸数据文件夹。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/360451
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号