0
0

人工智能大作业——人脸识别系统（最终）

写在前面
时间过得飞快，时间已经距离我发第一篇文章过去2年多了，也不再从事代码工作，偶然间上到csdn翻看文章经过，看到还是有些人关注人脸识别系统的后续的，我猜大概率是学弟学妹们正在被期末实验折磨中，翻了翻原先的代码还能找到就一并更完了吧，如果抄了我的作业记得来学长的评论区表示一下感谢哦（代码完全照抄必被老师发现，别那么傻）。
一、作业要求
　　基本任务：开发一个人脸识别系统，要求以ORL人脸数据库为实验数据，构造出一个完整的人脸识别系统，要求有界面，可选择输入单张图像并显示该图像，然后实现该图像的识别，并输出对应的识别结果图像。要求数据库中每个人的5张照片作为训练集，另外5张照片作为测试集，并统计其识别正确率。（实验采用的程序语言不限、人脸识别算法不限）
扩展任务：1、实现一个完整的人脸识别系统，照片自己采集，要求30人以上，实现摄像头与照片两种模式作为输入的人脸检测与识别，正确率要求95%以上。2、实现一个完整的多人人脸识别系统，照片自己采集，要求30人以上，实现摄像头与照片两种模式作为输入的多人脸检测与识别，正确率要求95%以上。
二、算法原理
　　基本思路是利用knn算法实现人脸识别，orl数据集的人脸识别系统与自定义数据集的多人人脸识别系统的系统大致逻辑为：模型训练，加载模型查找最邻近解，显示匹配到的信息。
　　模型训练过程为利用face_recognition模块识别出人脸位置，加上人脸信息标签后利用sklearn模块进行训练，得到相应的.clf分类器并保存，识别过程为利用保存的分类器进行相邻判断并找到最相邻的解的图像。
　　在机器的学习以及图像处理显示方面，调用sklearn、PIL、face_recognition等模块。在界面的展示以及用户的交互上，调用了tkinter模块。
三、人脸识别系统流程图与步骤说明
（一）orl数据集的人脸识别系统 流程图：在这里插入图片描述
步骤说明：
（1）选择训练集路径
在使用该系统前，需要先对人脸图像进行训练，所以首先得先指定训练集的路径位置。注意:训练集路径不能为空，且目录结构应大致为./train/s1/img1 img2 … ./train/s2 ./train/s3/img1 im2 …
（2）训练模型
进行模型训练，提示用户会造成系统卡顿，请耐心等待。
注意：①卡顿属于正常现象，是因为在模型训练过程中需要对大量图片进行处理，需要耐心等待。训练后会生成“trained_knn_model_orl.clf”文件，表示训练后形成的Knn分类器。默认保存路径是与该python文件同级目录下的位置。②训练过后系统会自动读取对应目录下的knn分类器，故下次使用时可不必再次训练。
（3）显示识别准确率
在模型训练完成后会自动对orl数据集中200张人像进行识别匹配进而计算正确率并显示。
（4）选择数据集中的待匹配图像
选择数据集中待匹配的图像进行检测，若格式不正确，系统会给予相应的提示。
（5）输出匹配的图像
从对应的训练集中查找到对应人像的照片进行显示。
（二）自定义数据集的多人人脸识别系统 流程图：
在这里插入图片描述
步骤说明：
（1）选择训练集路径
在使用该系统前，需要先对人脸图像进行训练，所以首先要先指定训练集的路径位置。注意:目录结构应大致为./train/s1/img1 img2 … ./train/s2 ./train/s3/img1 im2 …（这一步流程与上一个系统要求一致，如：目录结构要合理，训练集目录下有n个文件夹表示n个人的训练数据，文件夹名表示人物的名字，目录内的图片文件只能是这个人的单人的照片，否则不会训练成功）
（2）训练模型
进行模型训练，提示用户会造成系统卡顿，请耐心等待。训练后会在于文件同级目录上保存trained_knn_model_manyface_video.clf文件，这样下次使用时系统就会自动利用上面这个分类器进行图像识别。
（3）本地识别多人像照片
按下按钮后，会打开文件管理器，让用户选择一张照片进行识别。系统会利用trained_knn_model_manyface_video.clf这个分类器找出图像中所有人物的头像并利用knn算法匹配与它最相近的人物。之后系统会打开用户选中的图片并在图片上对人物图像加框和显示匹配到人物的名字。
（4）从摄像头识别多人像照片
按下按钮后，会打开摄像头采集用户当前的场景，对场景中的人物进行最近相邻匹配人物，并加框显示识别结果。

四、部分核心代码

  1. 训练模型的算法：
  2. #模型训练，得到分类器，即同级目录下的.clf文件
  3. def train_model(train_dir):
  4.     #指定KNN算法训练后分类器的文件名
  5.     model_save_path = "trained_knn_model_orl.clf"
  6.     X = []
  7.     y = []
  8.     #flag变量用于判断训练集的有效性
  9.     flag=False
  10.     # 对训练集中每个人的目录进行遍历,如C:/Users/Haifeng/OneDrive/桌面/face_identity_orl/knn_examples_orl2/train\s1..s2..s3....
  11.     for class_dir in os.listdir(train_dir):
  12.         #判断当前路径是目录,若s1 s2 s3 不是目录是文件则抛弃
  13.         if not os.path.isdir(os.path.join(train_dir, class_dir)):
  14.             continue
  15.         #对图像进行格式转换，转成jpg格式的图像,便于训练
  16.         bmpTojpg(os.path.join(train_dir, class_dir))
  17.         # 对每个人的图像进行遍历
  18.         for img_path in image_files_in_folder(os.path.join(train_dir, class_dir)):
  19.             # 将图片导入到numpy数组中
  20.             image = face_recognition.load_image_file(img_path)
  21.             # 查找图片中人脸（上下左右）的位置，图像中可能有多个人脸  face_locations的值类似[(135，536，198，474),()]
  22.             face_bounding_boxes = face_recognition.face_locations(image)
  23.             #若训练集中的图像只存在一张人脸，说明这是张合格的训练集，则加入集合进一步处理
  24.             if len(face_bounding_boxes) == 1:
  25.                 #只要有一张脸被训练到，即为训练成功
  26.                 flag=True
  27.                 # 将现在图像的脸部编码加载到训练集中
  28.                 X.append(face_recognition.face_encodings(image, known_face_locations=face_bounding_boxes)[0])
  29.                 y.append(class_dir)
  30.             # X加的是这个图像和人脸的位置Y加的是图像外面的文件夹名字
  31.     # 创建并训练KNN分类器
  32.     knn_clf = neighbors.KNeighborsClassifier(n_neighbors=2, algorithm='ball_tree', weights='distance')
  33.     knn_clf.fit(X, y)
  34.     # 以保存路径的格式要求保存分类器
  35.     if model_save_path is not None:
  36.         with open(model_save_path, 'wb') as f:
  37.             pickle.dump(knn_clf, f)
  39. #人脸预测匹配，根据传入的图像路径，进行人脸的匹配，返回匹配到人物的名字，以及原图像中相应的人脸坐标，以及是否存在匹配的人脸
  40. def predict(X_img_path):
  41.     #读入knn_clf模型
  42.     if knn_clf is None:
  43.         with open(model_path, 'rb') as f:
  44.             knn_clf = pickle.load(f)
  45.     # 加载图像和找到脸的位置
  46.     X_img = face_recognition.load_image_file(X_img_path)
  47.     X_face_locations = face_recognition.face_locations(X_img)
  48.     # 如果在图像中没有找到脸，则返回一个空集
  49.     if len(X_face_locations) == 0:
  50.         return []
  51.     # 将待测图片进行编码
  52.     faces_encodings = face_recognition.face_encodings(X_img, known_face_locations=X_face_locations)
  53.     # 使用knn模型对最优的解进行匹配
  54.     closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)
  55.     are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(X_face_locations))]
  56.     # 返回相应格式的类，分别为[[name1,name2],(上下左右位置坐标),人脸位置]
  57.     return [(pred, loc) if rec else ("unknown", loc) for pred, loc, rec in zip(knn_clf.predict(faces_encodings), X_face_locations, are_matches)]

五、界面展示

orl数据集的人脸识别系统
在这里插入图片描述
在这里插入图片描述
自定义数据集的多人人脸识别系统
在这里插入图片描述
在这里插入图片描述
六、源代码（千万不要照抄！千万不要照抄！千万不要照抄！）
（一）orl_face.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. import tkinter as tk
  5. import tkinter.filedialog
  6. from PIL import Image, ImageTk #调用图片处理模块，保证png后缀名可用
  7. import tkinter.messagebox
  8. import pickle
  9. import math
  10. from sklearn import neighbors
  11. import os
  12. import os.path
  13. import pickle
  14. from PIL import Image, ImageDraw
  15. import face_recognition
  16. from face_recognition.face_recognition_cli import image_files_in_folder
  18. #设置可支持的图片类型
  19. ALLOWED_EXTENSIONS = {'bmp','png', 'jpg', 'jpeg'}
  21. #将该路径下所有.bmp图像转换为.jpg图像
  22. def bmpTojpg(dir_path):
  23.     for fileName in os.listdir(dir_path):
  24.         file_path=os.path.join(dir_path,fileName)
  25.         if os.path.split(file_path)[-1].split(".")[-1] != 'bmp':
  26.             continue
  27.         newFileName = fileName[0:fileName.find(".bmp")] + ".jpg"
  28.         im = Image.open(file_path)
  29.         rgb = im.convert('RGB')  # 灰度转RGB
  30.         rgb.save(dir_path + "\\" + newFileName)
  31.         os.remove(file_path)
  33.     # command = "del " + dir_path + "\\*.bmp"
  34.     # os.system(command)
  35.     # os.remove(dir_path+"\\*.bmp")
  37. #人脸识别核心算法，通过传入数据集图像，通过训练得到的knn分类器进行人脸匹配
  38. def predict(X_img_path, knn_clf=None, model_path=None, distance_threshold=0.6):
  39.     # 读取knn分类器
  40.     if knn_clf is None:
  41.         with open(model_path, 'rb') as f:
  42.             knn_clf = pickle.load(f)
  44.     # 加载图像文件
  45.     X_img = face_recognition.load_image_file(X_img_path)
  46.     #寻找人脸特征
  47.     X_face_locations = face_recognition.face_locations(X_img)
  49.     # 如果没有人脸特征，则返回空集
  50.     if len(X_face_locations) == 0:
  51.         return [("unknown", (0,0,0,0))]
  52.     # 为数据集人脸编码
  53.     faces_encodings = face_recognition.face_encodings(X_img, known_face_locations=X_face_locations)
  55.     # 使用knn模型匹配最优的人脸
  56.     closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)
  57.     are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(X_face_locations))]
  59.     # 返回人脸的位置信息和对应人的姓名并删除不在阈值内的分类
  60.     return [(pred, loc) if rec else ("unknown", loc) for pred, loc, rec in zip(knn_clf.predict(faces_encodings), X_face_locations, are_matches)]
  62. #获取目录
  63. def askdirectory():
  64.     dir_path=tk.filedialog.askdirectory()
  65.     path.set(dir_path)
  67. #模型训练
  68. def train_model(train_dir):
  69.     # print(dir_path)
  70.     # print("Training KNN classifier...")
  71.     #对训练集路径的合法性进行判断并给出提示
  72.     if not os.path.isdir(train_dir):
  73.         tk.messagebox.showerror(title="路径错误", message="训练模型路径不能为空")
  74.         return
  75.     #与用户交互
  76.     if not tk.messagebox.askyesno(title="系统提示", message="模型训练会导致系统卡顿10~15s\n\t请耐心等待"):
  77.         return
  79.     #指定KNN算法训练后分类器的文件名
  80.     model_save_path = "trained_knn_model_orl.clf"
  82.     X = []
  83.     y = []
  85.     #flag变量用于判断训练集的有效性
  86.     flag=False
  88.     # 对训练集中每个人的目录进行遍历,如C:/Users/杨海丰/OneDrive/桌面/face_identity_orl/knn_examples_orl2/train\s1..s2..s3....
  89.     for class_dir in os.listdir(train_dir):
  90.         #判断当前路径是目录,若s1 s2 s3 不是目录是文件则抛弃
  91.         if not os.path.isdir(os.path.join(train_dir, class_dir)):
  92.             continue
  94.         #对图像进行格式转换，转成jpg格式的图像,便于训练
  95.         bmpTojpg(os.path.join(train_dir, class_dir))
  96.         # 对每个人的图像进行遍历
  97.         for img_path in image_files_in_folder(os.path.join(train_dir, class_dir)):
  98.             # 将图片导入到numpy数组中
  99.             image = face_recognition.load_image_file(img_path)
  100.             # 查找图片中人脸（上下左右）的位置，图像中可能有多个人脸  face_locations的值类似[(135，536，198，474),()]
  101.             face_bounding_boxes = face_recognition.face_locations(image)
  102.             #若训练集中的图像只存在一张人脸，说明这是张合格的训练集，则加入集合进一步处理
  103.             if len(face_bounding_boxes) == 1:
  104.                 #只要有一张脸被训练到，即为训练成功
  105.                 flag=True
  106.                 # 将现在图像的脸部编码加载到训练集中
  107.                 X.append(face_recognition.face_encodings(image, known_face_locations=face_bounding_boxes)[0])
  108.                 y.append(class_dir)
  109.                 # X加的是这个图像和人脸的位置 Y加的是图像外面的文件夹名字
  111.     #若训练集中一张人脸也没有检测到，则提示用户更换训练集
  112.     if not flag:
  113.         tk.messagebox.showerror(title="训练集错误", message="训练集有误,请更换训练集")
  114.         return
  115.     # 创建并训练KNN分类器
  116.     knn_clf = neighbors.KNeighborsClassifier(n_neighbors=2, algorithm='ball_tree', weights='distance')
  117.     knn_clf.fit(X, y)
  119.     # 以保存路径的格式要求保存分类器
  120.     if model_save_path is not None:
  121.         with open(model_save_path, 'wb') as f:
  122.             pickle.dump(knn_clf, f)
  124.     #默认检测正确率时orl未训练的后200张照片位于与train目录同级下的test文件夹中
  125.     test_dir = os.path.join(os.path.split(train_dir)[0],'test')
  126.     print(test_dir)
  127.     # 计算识别的正确率
  128.     correct=sum=0.0
  129.     for class_dir in os.listdir(test_dir):
  130.         # 判断当前路径是目录,若s1 s2 s3 不是目录是文件则抛弃
  131.         if not os.path.isdir(os.path.join(test_dir, class_dir)):
  132.             continue
  133.         # 对图像进行格式转换，转成jpg格式的图像,便于训练
  134.         bmpTojpg(os.path.join(test_dir, class_dir))
  135.         for img_path in image_files_in_folder(os.path.join(test_dir, class_dir)):
  136.             sum=sum+1
  137.             predictions = predict(img_path, model_path="trained_knn_model_orl.clf")
  138.             for name, (top, right, bottom, left) in predictions:
  139.                 if name==class_dir:
  140.                     correct=correct+1
  141.                 break;
  143.     #显示准确率信息
  144.     tk.Label(window, font=('Arial', 16), text="准确率:{}".format(correct/sum)).grid(row=7, column=4, columnspan=1)
  145.     #与用户进行交互
  146.     tk.messagebox.showinfo(title="信息",message="训练已完成,可识别人脸")
  148.     # print("Training complete!")
  150. #人脸识别,利用训练好的knn分类器进行orl人脸的识别
  151. def recog_orl_face(train_path):
  152.     #打开文件筛选器筛选文件
  153.     img_path=tk.filedialog.askopenfilename()
  154.     #判断是否选中的文件为一张图片，如果是则打开并显示，否则与用户进行交互
  155.     try:
  156.         img1=Image.open(img_path)
  157.         photo1 = ImageTk.PhotoImage(img1)
  158.         img_label1.config(imag=photo1)
  159.         # tkinter.update()
  160.         img_label1.image = photo1
  161.     except:
  162.         tk.messagebox.showerror(title="图片格式有误", message="图片格式有误，请选择一张图片")
  163.         return
  164.     #进行人脸预测,img_path是数据集中人脸的路径,model_path是训练后得到的KNN分类器
  165.     predictions = predict(img_path, model_path="trained_knn_model_orl.clf")
  166.     # print(predictions)
  167.     #对人脸进行识别
  168.     for name, (top, right, bottom, left) in predictions:
  169.         # print(name)
  170.         #如果该照片未找到匹配的图像，则提示用户 匹配失败
  171.         if(name=="unknown"):
  172.             tk.messagebox.showerror(title="匹配失败", message="未找到匹配的人脸图像")
  173.             img_label1.grid_forget()
  174.         else:
  175.             try:
  176.                 # 从训练集中找一张对应识别任务的图像打开并显示
  177.                 testphoto_dir = os.path.join(train_path, name)
  178.                 # print(testphoto_dir)
  179.                 testphoto_path = os.path.join(testphoto_dir, os.listdir(testphoto_dir)[0])
  180.                 # print(testphoto_path)
  181.                 img2 = Image.open(testphoto_path)
  182.                 photo2 = ImageTk.PhotoImage(img2)
  183.                 img_label2.config(imag=photo2)
  184.                 # tkinter.update()
  185.                 img_label2.image = photo2
  186.             except:
  187.                 tk.messagebox.showerror(title="训练集路径有误", message="\t\t匹配成功\n但训练集路径选择错误，导致系统无法显示对应人物图像")
  188.         break;
  189. #主程序入口
  190. if __name__ == "__main__":
  191.     # 建立窗口window
  192.     window = tk.Tk()
  193.     # 给窗口的可视化起名字
  194.     window.title('ORL人脸识别系统')
  195.     # 设定窗口的大小(长 * 宽)
  196.     window.geometry('400x250')
  198.     path = tk.StringVar()
  199.     #添加Label标签
  200.     tk.Label(window, font=('Arial', 14), text="训练集的路径").grid(row=0, column=1, columnspan=2)
  202.     #添加Entry输入框，用于显示用户载入的训练集路径
  203.     entry_dir=tk.Entry(window,textvariable=path)
  204.     entry_dir.grid(row=0, column=3, columnspan=3)
  206.     #添加 选择路径、训练模型 2个按钮
  207.     tk.Button(window, font=('Arial', 12), text="选择路径", command=askdirectory).grid(row=0, column=6)
  208.     tk.Button(window, font=('Arial', 12), text="训练模型",command=lambda:train_model(entry_dir.get())).grid(row=2, column=4)
  210.     # 添加2个Label标签用来当做放置图片的位置,一个是显示待识别的图像，一个是显示识别后结果的图像
  211.     img_label1 = tk.Label(window)
  212.     img_label1.grid(row=4,column=1,rowspan=3, columnspan=2,padx=4, pady=20)
  214.     img_label2 = tk.Label(window)
  215.     img_label2.grid(row=4, column=5, rowspan=3, columnspan=2, padx=4, pady=20)
  217.     #添加 选择人像并识别的按钮
  218.     tk.Button(window, font=('Arial', 12), text="选择人像并识别", command=lambda: recog_orl_face(entry_dir.get())).grid(row=5,
  219.                                                                                                                 column=3,
  220.                                                                                                                 columnspan=2)
  222.     # 主窗口循环显示
  223.     window.mainloop()

（二）multi_face.py

  1. #!/usr/bin/env python
  3. import tkinter as tk
  4. import tkinter.filedialog
  5. from PIL import Image, ImageTk#调用图片处理模块，保证png后缀名可用
  6. import tkinter.messagebox
  7. import pickle
  8. import math
  9. from sklearn import neighbors
  10. import os
  11. import os.path
  12. import pickle
  13. from PIL import Image, ImageDraw
  14. import face_recognition
  15. from face_recognition.face_recognition_cli import image_files_in_folder
  16. import cv2
  17. import numpy as np
  19. #将该路径下所有.bmp图像转换为.jpg图像
  20. def bmpTojpg(dir_path):
  21.     for fileName in os.listdir(dir_path):
  22.         file_path=os.path.join(dir_path,fileName)
  23.         if os.path.split(file_path)[-1].split(".")[-1] != 'bmp':
  24.             continue
  25.         newFileName = fileName[0:fileName.find(".bmp")] + ".jpg"
  26.         im = Image.open(file_path)
  27.         rgb = im.convert('RGB')  # 灰度转RGB
  28.         rgb.save(dir_path + "\\" + newFileName)
  29.         os.remove(file_path)
  30. # 使得识别结果可视化，即将图像以图片形式打开，且在人像上加框
  31. def show_prediction_labels_on_image(img_path, predictions):
  32.     pil_image = Image.open(img_path).convert("RGB")
  33.     draw = ImageDraw.Draw(pil_image)
  34.     for name, (top, right, bottom, left) in predictions:
  35.         # 利用pillow模块在图片上画一个矩形
  36.         draw.rectangle(((left, top), (right, bottom)), outline=(255, 0, 0),width=3)
  37.         #字符编码设置为utf-8
  38.         name = name.encode("UTF-8")
  40.         text_width, text_height = draw.textsize(name)
  41.         draw.rectangle(((left, bottom - text_height - 10), (right, bottom)), fill=(0,0,0),outline=(255, 0, 0),width=3)
  42.         draw.text((left + 6, bottom - text_height - 5), name, fill=(255, 255, 255, 255))
  44.     # 从内存中移除pillow库
  45.     del draw
  47.     # 显示结果
  48.     pil_image.show()
  50. #模型训练
  51. def train_model(train_dir):
  52.     # print(dir_path)
  53.     # print("Training KNN classifier...")
  54.     #对训练集路径的合法性进行判断并给出提示
  55.     if not os.path.isdir(train_dir):
  56.         tk.messagebox.showerror(title="路径错误", message="训练模型路径不能为空")
  57.         return
  58.     #与用户交互
  59.     if not tk.messagebox.askyesno(title="系统提示", message="模型训练会导致系统卡顿10~15s\n\t请耐心等待"):
  60.         return
  62.     #指定KNN算法训练后分类器的文件名
  63.     model_save_path = "trained_knn_model_manyface_video.clf"
  65.     X = []
  66.     y = []
  67.     #flag变量用于判断训练集的有效性
  68.     flag=False
  69.     print(train_dir)
  70.     # 对训练集中每个人的目录进行遍历,如C:/Users/杨海丰/OneDrive/桌面/face_identity_orl/knn_examples_orl2/train\s1..s2..s3....
  71.     for class_dir in os.listdir(train_dir):
  72.         #判断当前路径是目录,若s1 s2 s3 不是目录是文件则抛弃
  73.         if not os.path.isdir(os.path.join(train_dir, class_dir)):
  74.             continue
  75.         #对图像进行格式转换，转成jpg格式的图像,便于训练
  76.         bmpTojpg(os.path.join(train_dir, class_dir))
  77.         # 对每个人的图像进行遍历
  78.         for img_path in image_files_in_folder(os.path.join(train_dir, class_dir)):
  79.             # 将图片导入到numpy数组中
  80.             image = face_recognition.load_image_file(img_path)
  81.             # 查找图片中人脸（上下左右）的位置，图像中可能有多个人脸  face_locations的值类似[(135，536，198，474),()]
  82.             face_bounding_boxes = face_recognition.face_locations(image)
  83.             #若训练集中的图像只存在一张人脸，说明这是张合格的训练集，则加入集合进一步处理
  84.             if len(face_bounding_boxes) == 1:
  85.                 #只要有一张脸被训练到，即为训练成功
  86.                 flag=True
  87.                 # 将现在图像的脸部编码加载到训练集中
  88.                 X.append(face_recognition.face_encodings(image, known_face_locations=face_bounding_boxes)[0])
  89.                 y.append(class_dir)
  90.                 # X加的是这个图像和人脸的位置 Y加的是图像外面的文件夹名字
  92.     #若训练集中一张人脸也没有检测到，则提示用户更换训练集
  93.     if not flag:
  94.         tk.messagebox.showerror(title="训练集错误", message="训练集有误,请更换训练集")
  95.         return
  96.     # 创建并训练KNN分类器
  97.     knn_clf = neighbors.KNeighborsClassifier(n_neighbors=2, algorithm='ball_tree', weights='distance')
  98.     knn_clf.fit(X, y)
  100.     # 以保存路径的格式要求保存分类器
  101.     if model_save_path is not None:
  102.         with open(model_save_path, 'wb') as f:
  103.             pickle.dump(knn_clf, f)
  105.     tk.messagebox.showinfo(title="信息",message="训练已完成,可进行人脸识别")
  107.     # print("Training complete!")
  108. #人脸预测
  109. def predict(X_img_path, knn_clf=None, model_path=None, distance_threshold=0.6):
  110.     #读入knn_clf模型
  111.     if knn_clf is None:
  112.         with open(model_path, 'rb') as f:
  113.             knn_clf = pickle.load(f)
  114.     # print(X_img_path)
  115.     # 加载图像和找到脸的位置
  116.     X_img = face_recognition.load_image_file(X_img_path)
  117.     X_face_locations = face_recognition.face_locations(X_img)
  119.     # 如果在图像中没有找到脸，则返回一个空集
  120.     if len(X_face_locations) == 0:
  121.         return []
  123.     # 将待测图片进行编码
  124.     faces_encodings = face_recognition.face_encodings(X_img, known_face_locations=X_face_locations)
  126.     # 使用knn模型对最优的解进行匹配
  127.     closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)
  128.     are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(X_face_locations))]
  130.     # 返回相应格式的类，分别为[[name1,name2],(上下左右位置坐标),人脸位置]
  131.     return [(pred, loc) if rec else ("unknown", loc) for pred, loc, rec in zip(knn_clf.predict(faces_encodings), X_face_locations, are_matches)]
  132. #获取目录
  133. def askdirectory():
  134.     dir_path=tk.filedialog.askdirectory()
  135.     path.set(dir_path)
  136. #从照片识别多人人脸
  137. def recog_many_face():
  138.     img_path = tk.filedialog.askopenfilename()
  139.     # 判断是否选中的文件为一张图片，如果是则打开并显示，否则与用户进行交互
  140.     try:
  141.         img1 = Image.open(img_path)
  142.     except:
  143.         tk.messagebox.showerror(title="图片格式有误", message="图片格式有误，请选择一张图片")
  144.         return
  145.     # 进行人脸预测,img_path是数据集中人脸的路径,model_path是训练后得到的KNN分类器
  146.     predictions = predict(img_path, model_path="trained_knn_model_manyface_video.clf")
  147.     # print(predictions)
  148.     # 对人脸进行识别
  149.     show_prediction_labels_on_image(img_path, predictions)
  151. #从摄像头进行认脸
  152. def recog_from_video(train_dir,knn_clf=None):
  153.     #读入knn训练模型
  154.     model_path = "trained_knn_model_manyface_video.clf"
  155.     if knn_clf is None:
  156.         with open(model_path, 'rb') as f:
  157.             knn_clf = pickle.load(f)
  158.     # 开启摄像头
  159.     camera = cv2.VideoCapture(0)
  161.     while True:
  162.         # 抽一帧作为检测人脸的图像
  163.         ret, frame = camera.read()
  165.         # 将图像转换为rgb图像
  166.         rgb_frame = frame[:, :, ::-1]
  168.         # 处理得到所有人脸的位置与编码信息
  169.         face_locations = face_recognition.face_locations(rgb_frame)
  170.         faces_encodings = face_recognition.face_encodings(rgb_frame, face_locations)
  171.         #异常处理，如果得到的人脸为空，则跳出取下一张
  172.         if faces_encodings == []:
  173.             continue
  174.         #求与多人脸相对应最优的匹配人脸
  175.         closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)
  176.         are_matches = [closest_distances[0][i][0] <= 0.53 for i in range(len(face_locations))]
  177.         #显示人脸信息,name表示该人的名字,第二个参数是检测到人脸的位置信息,rec表示是否有匹配到的最优解，如果不为空，则必有人脸被匹配到
  178.         for name, (top, right, bottom, left), rec in zip(knn_clf.predict(faces_encodings), face_locations, are_matches):
  179.             if not rec:
  180.                 name = "unknown"
  181.                 print(name)
  182.             print(name)
  183.             #画框
  184.             cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)
  185.             cv2.rectangle(frame, (left, bottom - 35), (right, bottom), (0, 0, 255), cv2.FILLED)
  186.             font = cv2.FONT_HERSHEY_DUPLEX
  187.             cv2.putText(frame, name, (left + 6, bottom - 6), font, 0.8, (255, 255, 255), 1)
  189.         cv2.imshow('multi_face_recognition', frame)
  190.         # 按q键退出人脸检测
  191.         if cv2.waitKey(1) & 0xFF == ord('q'):
  192.             break
  193.     camera.release()
  194.     cv2.destroyAllWindows()
  195. if __name__ == "__main__":
  196.     # 建立窗口window
  197.     window = tk.Tk()
  198.     # 给窗口的可视化起名字
  199.     window.title('多人脸识别系统')
  200.     # 设定窗口的大小(长 * 宽)
  201.     window.geometry('450x180')
  203.     path = tk.StringVar()
  204.     #添加Label标签
  205.     tk.Label(window, font=('Arial', 14), text="训练集的路径").grid(row=0, column=1, columnspan=2)
  207.     #添加Entry输入框，用于显示用户载入的训练集路径
  208.     entry_dir=tk.Entry(window,textvariable=path)
  209.     entry_dir.grid(row=0, column=3, columnspan=3)
  211.     #添加 选择路径、训练模型 2个按钮
  212.     tk.Button(window, font=('Arial', 12), text="选择路径", command=askdirectory).grid(row=0, column=6)
  213.     tk.Button(window, font=('Arial', 12), text="训练模型",command=lambda:train_model(entry_dir.get())).grid(row=2, column=4)
  215.     #添加 选择人像并识别的按钮
  216.     tk.Button(window, font=('Arial', 12), text="本地识别多人像照片", command=lambda: recog_many_face()).grid(row=5,
  217.                                                                                                                 column=1,
  218.                                                                                                                 columnspan=2)
  219.     tk.Button(window, font=('Arial', 12), text="从摄像头识别多人人像", command=lambda: recog_from_video(entry_dir.get())).grid(row=5,
  220.                                                                                                                column=5,
  221.                                                                                                                columnspan=2)
  222.     tk.Label(window, font=('Arial', 14)).grid(row=3)
  223.     tk.Label(window, font=('Arial', 14)).grid(row=4)
  225.     # 主窗口循环显示
  226.     window.mainloop()

代码可能未能完全实现全部功能，交差是没问题的，但是具体什么问题也忘记了，训练和测试数据集本想一并上传，但gitee的ssh安全配置出了点问题上报不了，如果还有机会到时候会贴在评论区。
写在最后：大学四年是一段美好而短暂的时光，原先没有疫情的学习生活可能会更加多彩，但这丝毫不影响这四年的轻松与愉悦。工作后常常会想起在大学的时光，那时至少没有生活的压力，不知道屏幕前的你是什么感受，好好珍惜，仅以此篇为早以结束的大学生活画上再一个句号。

标签： 人工智能 人脸识别 计算机视觉
本文转载自: https://blog.csdn.net/qq_41745118/article/details/127823863
版权归原作者 小平我自豪 所有， 如有侵权，请联系我们删除。
登录后发布评论

“人工智能大作业——人脸识别系统（最终）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。