毕业设计：基于CNN做人脸识别_基于cnn人脸识别实践的

基于CNN做人脸识别

首先，我是考虑，这系统在Windows下做还是在Linux、Ubuntu下做比较好？
然后，我都检测过，Windows下可以用python、anaconda写代码都可以。当然，和在Linux和Ubuntu下使用的库和包肯定也是一样的。目的就在于那种形式，比较简单，这是我的想法。何必给自己添加难度呢？
后来，我是选择在Ubuntu下做人脸识别。至于为什么，简单是一回事，后面还有原因，我会一一讲解的。

我写了一份草图，我这几周分别做哪些事。

搭建环境

1. 将Ubuntu系统安装好，然后配置环境
   安装啊python、pip
   这里小编给个建议，安装好ubuntu第一步就是把数据源给改了，那样之后下载库或者包的时候会比官方快好多。个人推荐清华的源https://pypi.tuna.tsinghua.edu.cn/simple
   
   重新导入完后
   执行下更新

sudo apt-get update
sudo apt-get upgrade
1
2

需要的包的大概有：numpy、opencv-python、keras、scikit-learn、tensorflow、dlib、pandas（有条件可以考虑基于GPU的）以及神经网络所需的各种包及库等等
1

sudo pip install opencv-python
sudo pip install keras
sudo pip install scikit-learn
sudo pip install tensorflow
sudo pip install dlib
sudo pip install pandas
1
2
3
4
5
6

主要分为五个模块：

1.人脸收集
2.头像提取
3.尺寸变换
4.训练
5.识别

话不多说上代码：
测试摄像头
文件名为：how_to_use_camera.py
这里说明下，小编都是用python来编译的

# OpenCv 调用摄像头
# 默认调用笔记本摄像头

# Author:   coneypo
# Blog:     http://www.cnblogs.com/AdaminXie
# GitHub:   https://github.com/coneypo/Dlib_face_recognition_from_camera
# Mail:     coneypo@foxmail.com

import cv2

cap = cv2.VideoCapture(0)

# cap.set(propId, value)
# 设置视频参数: propId - 设置的视频参数, value - 设置的参数值
cap.set(3, 480)

# cap.isOpened() 返回 true/false, 检查摄像头初始化是否成功
print(cap.isOpened())

# cap.read()
""" 
返回两个值
    先返回一个布尔值, 如果视频读取正确, 则为 True, 如果错误, 则为 False; 
    也可用来判断是否到视频末尾;
    
    再返回一个值, 为每一帧的图像, 该值是一个三维矩阵;
    
    通用接收方法为: 
        ret,frame = cap.read();
        ret: 布尔值;
        frame: 图像的三维矩阵;
        这样 ret 存储布尔值, frame 存储图像;
        
        若使用一个变量来接收两个值, 如:
            frame = cap.read()
        则 frame 为一个元组, 原来使用 frame 处需更改为 frame[1]
"""

while cap.isOpened():
    ret_flag, img_camera = cap.read()
    cv2.imshow("camera", img_camera)

    # 每帧数据延时 1ms, 延时为0, 读取的是静态帧
    k = cv2.waitKey(1)

    # 按下 's' 保存截图
    if k == ord('s'):
        cv2.imwrite("test.jpg", img_camera)

    # 按下 'q' 退出
    if k == ord('q'):
        break

# 释放所有摄像头
cap.release()

# 删除建立的所有窗口
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

python3  how_to_use_camera.py
1

提取头像
下面的视频自己可以随便找一部，人脸多的。代码的目的就是截取人，为之后收集人脸做铺垫。以下代码中有存在路径，自己注意修改自己文件夹目录在哪。

文件名：capture.py

import cv2
print(cv2.__version__)

# /home/zjipc/Documents


vc = cv2.VideoCapture('D:\picture\mda-ihuh3xjpbi20te2c.MP4' )  # 读入视频文件
c = 1
caps = 0

if vc.isOpened():  # 判断是否正常打开
    rval, frame = vc.read()
    caps = vc.get(7)  # 获取视频总帧数

else:
    rval = False

timeF = int(caps / 30)

timeF = 100  # 视频帧计数间隔频率

i = 1
while rval:  # 循环读取视频帧
    rval, frame = vc.read()
    # print("c="+str(c))
    if (c % timeF == 0):  # 每隔timeF帧进行存储操作
        path = 'D:\picture\pi'  + str(i).zfill(6) + '.jpg'
        print("正在保存：" + path)
        cv2.imwrite(path, frame)  # 存储为图像
        i = i + 1
    c = c + 1
    cv2.waitKey(1)
vc.release()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

python3 capture.py
1

人脸收集
可以通俗的理解为注册人脸
文件名：get_faces_from_camera.py

import dlib         # 人脸处理的库 Dlib
import numpy as np  # 数据处理的库 Numpy
import cv2          # 图像处理的库 OpenCv

import os           # 读写文件
import shutil       # 读写文件

# Dlib 正向人脸检测器
detector = dlib.get_frontal_face_detector()

# Dlib 68 点特征预测器
predictor = dlib.shape_predictor('data/data_dlib/shape_predictor_68_face_landmarks.dat')

# OpenCv 调用摄像头
cap = cv2.VideoCapture(0)

# 设置视频参数
cap.set(3, 480)

# 人脸截图的计数器
cnt_ss = 0

# 存储人脸的文件夹
current_face_dir = 0

# 保存 photos/csv 的路径
path_photos_from_camera = "data/data_faces_from_camera/"
path_csv_from_photos = "data/data_csvs_from_camera/"


# 新建保存人脸图像文件和数据CSV文件夹
def pre_work_mkdir():

    # 新建文件夹
    if os.path.isdir(path_photos_from_camera):
        pass
    else:
        os.mkdir(path_photos_from_camera)
    if os.path.isdir(path_csv_from_photos):
        pass
    else:
        os.mkdir(path_csv_from_photos)


pre_work_mkdir()


##### optional/可选, 默认关闭 #####
# 删除之前存的人脸数据文件夹
def pre_work_deldir():
    # 删除之前存的人脸数据文件夹
    # 删除 "/data_faces_from_camera/person_x/"...
    folders_rd = os.listdir(path_photos_from_camera)
    for i in range(len(folders_rd)):
        shutil.rmtree(path_photos_from_camera+folders_rd[i])

    csv_rd = os.listdir(path_csv_from_photos)
    for i in range(len(csv_rd)):
        os.remove(path_csv_from_photos+csv_rd[i])



# 如果有之前录入的人脸
# 在之前 person_x 的序号按照 person_x+1 开始录入
if os.listdir("data/data_faces_from_camera/"):
    # 获取已录入的最后一个人脸序号
    person_list = os.listdir("data/data_faces_from_camera/")
    person_list.sort()
    person_num_latest = int(str(person_list[-1]).split("_")[-1])
    person_cnt = person_num_latest

# 如果第一次存储或者没有之前录入的人脸, 按照 person_1 开始录入
else:
    person_cnt = 0

# 之后用来控制是否保存图像的 flag
save_flag = 1

while cap.isOpened():
    # 480 height * 640 width
    flag, img_rd = cap.read()
    kk = cv2.waitKey(1)

    img_gray = cv2.cvtColor(img_rd, cv2.COLOR_RGB2GRAY)
    
    # 人脸数 faces
    faces = detector(img_gray, 0)

    # 待会要写的字体
    font = cv2.FONT_HERSHEY_COMPLEX

    # 按下 'n' 新建存储人脸的文件夹
    if kk == ord('n'):
        person_cnt += 1
        current_face_dir = path_photos_from_camera + "person_" + str(person_cnt)
        os.makedirs(current_face_dir)
        print('\n')
        print("新建的人脸文件夹: ", current_face_dir)

        # 将人脸计数器清零
        cnt_ss = 0

    # 检测到人脸
    if len(faces) != 0:
        # 矩形框
        for k, d in enumerate(faces):
            # 计算矩形大小
            # (x,y), (宽度width, 高度height)
            pos_start = tuple([d.left(), d.top()])
            pos_end = tuple([d.right(), d.bottom()])

            # 计算矩形框大小
            height = (d.bottom() - d.top())
            width = (d.right() - d.left())

            hh = int(height/2)
            ww = int(width/2)

            # 设置颜色 / The color of rectangle of faces detected
            color_rectangle = (255, 255, 255)
            # if (d.right()+ww) > 640 or (d.bottom()+hh > 480) or (d.left()-ww < 0) or (d.top()-hh < 0):
            #     cv2.putText(img_rd, "OUT OF RANGE", (20, 300), font, 0.8, (0, 0, 255), 1, cv2.LINE_AA)
            #     color_rectangle = (0, 0, 255)
            #     save_flag = 0
            # else:
            #     color_rectangle = (255, 255, 255)
            #     save_flag = 1

            cv2.rectangle(img_rd,
                          tuple([d.left() - ww, d.top() - hh]),
                          tuple([d.right() + ww, d.bottom() + hh]),
                          color_rectangle, 2)

            # 根据人脸大小生成空的图像
            im_blank = np.zeros((int(height*2), width*2, 3), np.uint8)

            if save_flag:
                # 按下 's' 保存摄像头中的人脸到本地
                if kk == ord('s'):
                    if os.path.isdir(current_face_dir):
                        cnt_ss += 1
                        # for ii in range(height*2):
                        #     for jj in range(width*2):
                        #             im_blank[ii][jj] = img_rd[d.top()-hh + ii][d.left()-ww + jj]
                                # print(im_blank[ii][jj])
                        cv2.imwrite(current_face_dir + "/img_face_" + str(cnt_ss) + ".jpg", img_rd)
                        print("写入本地：", str(current_face_dir) + "/img_face_" + str(cnt_ss) + ".jpg")
                    else:
                        print("请在按 'S' 之前先按 'N' 来建文件夹 / Please press 'N' before 'S'")

    # 显示人脸数
    cv2.putText(img_rd, "Faces: " + str(len(faces)), (20, 100), font, 0.8, (0, 255, 0), 1, cv2.LINE_AA)

    # 添加说明
    cv2.putText(img_rd, "Face Register", (20, 40), font, 1, (0, 0, 0), 1, cv2.LINE_AA)
    cv2.putText(img_rd, "N: New face folder", (20, 350), font, 0.8, (0, 0, 0), 1, cv2.LINE_AA)
    cv2.putText(img_rd, "S: Save current face", (20, 400), font, 0.8, (0, 0, 0), 1, cv2.LINE_AA)
    cv2.putText(img_rd, "Q: Quit", (20, 450), font, 0.8, (0, 0, 0), 1, cv2.LINE_AA)

    # 按下 'q' 键退出
    if kk == ord('q'):
        break

    # 窗口显示
    # cv2.namedWindow("camera", 0) # 如果需要摄像头窗口大小可调
    cv2.imshow("camera", img_rd)

# 释放摄像头
cap.release()

# 删除建立的窗口
cv2.destroyAllWindows()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

python3 get_faces_from_camera.py
1

接着上面的代码写入后，在data文件里，会自动生成照片管理文件，这也是在ubuntu下做的好处，我们可以借助库建立数据存储，不需要在安装数据库。

人脸识别的核心
文件名：face_reco_from_camera.py

#coding=utf-8
# 摄像头实时人脸识别
import dlib          # 人脸处理的库 Dlib
import numpy as np   # 数据处理的库 numpy
import cv2           # 图像处理的库 OpenCv
import pandas as pd  # 数据处理的库 Pandas

# 人脸识别模型，提取128D的特征矢量
# face recognition model, the object maps human faces into 128D vectors
facerec = dlib.face_recognition_model_v1("data/data_dlib/dlib_face_recognition_resnet_model_v1.dat")


# 计算两个128D向量间的欧式距离
def return_euclidean_distance(feature_1, feature_2):
    feature_1 = np.array(feature_1)
    feature_2 = np.array(feature_2)
    np.linalg.norm(feature_1 - feature_2)
    dist = np.sqrt(np.sum(np.square(feature_1 - feature_2)))
    print("e_distance: ", dist)

    if dist > 0.4:
        return "diff"
    else:
        return "same"


# 处理存放所有人脸特征的 csv
path_features_known_csv = "data/features_all.csv"
csv_rd = pd.read_csv(path_features_known_csv, header=None)

# 存储的特征人脸个数
# print(csv_rd.shape[0])

# 用来存放所有录入人脸特征的数组
features_known_arr = []

# 读取已知人脸数据
# known faces
for i in range(csv_rd.shape[0]):
    features_someone_arr = []
    print(csv_rd.ix[i, :])
    for j in range(0, len(csv_rd.ix[i, :])):

        features_someone_arr.append(csv_rd.ix[i, :][j])
    features_known_arr.append(features_someone_arr)
print("Faces in Database：", len(features_known_arr))

# Dlib 检测器和预测器
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor('data/data_dlib/shape_predictor_68_face_landmarks.dat')

# 创建 cv2 摄像头对象
cap = cv2.VideoCapture(0)

# cap.set(propId, value)
# 设置视频参数，propId 设置的视频参数，value 设置的参数值
cap.set(3, 480)


# 返回一张图像多张人脸的 128D 特征
def get_128d_features(img_gray):
    faces = detector(img_gray, 1)
    if len(faces) != 0:
        face_des = []
        for i in range(len(faces)):
            shape = predictor(img_gray, faces[i])
            face_des.append(facerec.compute_face_descriptor(img_gray, shape))
    else:
        face_des = []
    return face_des


# cap.isOpened() 返回 true/false 检查初始化是否成功
while cap.isOpened():

    flag, img_rd = cap.read()
    kk = cv2.waitKey(1)

    # 取灰度
    img_gray = cv2.cvtColor(img_rd, cv2.COLOR_RGB2GRAY)

    # 人脸数 faces
    faces = detector(img_gray, 0)

    # 待会要写的字体
    font = cv2.FONT_HERSHEY_COMPLEX

    # 存储当前摄像头中捕获到的所有人脸的坐标/名字
    pos_namelist = []
    name_namelist = []

    # 按下 q 键退出
    if kk == ord('q'):
        break
    else:
        # 检测到人脸
        if len(faces) != 0:
            # 获取当前捕获到的图像的所有人脸的特征，存储到 features_cap_arr
            features_cap_arr = []
            for i in range(len(faces)):
                shape = predictor(img_rd, faces[i])
                features_cap_arr.append(facerec.compute_face_descriptor(img_rd, shape))

            # 遍历捕获到的图像中所有的人脸
            for k in range(len(faces)):
                # 让人名跟随在矩形框的下方
                # 确定人名的位置坐标
                # 先默认所有人不认识，是 unknown
                name_namelist.append("unknown")

                # 每个捕获人脸的名字坐标
                pos_namelist.append(tuple([faces[k].left(), int(faces[k].bottom() + (faces[k].bottom() - faces[k].top())/4)]))

                # 对于某张人脸，遍历所有存储的人脸特征
                for i in range(len(features_known_arr)):
                    print("with person_", str(i+1), "the")
                    # 将某张人脸与存储的所有人脸数据进行比对
                    compare = return_euclidean_distance(features_cap_arr[k], features_known_arr[i])
                    if compare == "same":  # 找到了相似脸
                        # 在这里修改 person_1, person_2 ... 的名字
                        # 这里只写了前三个
                        # 可以在这里改称 Jack, Tom and others
                        # Here you can modify the names shown on the camera
                        if i == 0:
                            name_namelist[k] = "zhangsan"
                        elif i == 1:
                            name_namelist[k] = "jiaqing"
                        elif i == 2:
                            name_namelist[k] = "Unkonw"
                            
                # 矩形框
                for kk, d in enumerate(faces):
                    # 绘制矩形框
                    cv2.rectangle(img_rd, tuple([d.left(), d.top()]), tuple([d.right(), d.bottom()]), (0, 255, 255), 2)

            # 在人脸框下面写人脸名字
            for i in range(len(faces)):
                cv2.putText(img_rd, name_namelist[i], pos_namelist[i], font, 0.8, (0, 255, 255), 1, cv2.LINE_AA)

    print("Name list now:", name_namelist, "\n")

    # 窗口显示
    cv2.imshow("camera", img_rd)

# 释放摄像头
cap.release()

# 删除建立的窗口
cv2.destroyAllWindows()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

python3 face_reco_from_camera.py
1

这两张照片都是我自己，为什么第二张识别不了呢？ 这就是深度学习中的问题了。机器它识别也有限的。所以我们要训练模型，使它的准确度更高。当然，手机美颜照片也是不行的

训练
文件名：get_features_into_CSV.py

# 从人脸图像文件中提取人脸特征存入 CSV
# Get features from images and save into features_all.csv
# 增加录入多张人脸到 CSV 的功能

# return_128d_features()          获取某张图像的 128D 特征
# write_into_csv()                获取某个路径下所有图像的特征，并写入 CSV
# compute_the_mean()              从 CSV 中读取 128D 特征，并计算特征均值

import cv2
import os
import dlib
from skimage import io
import csv
import numpy as np
import pandas as pd
#import io

# 要读取人脸图像文件的路径
path_photos_from_camera = "data/data_faces_from_camera/"
# 储存人脸特征 csv 的路径
path_csv_from_photos = "data/data_csvs_from_camera/"

# Dlib 正向人脸检测器
detector = dlib.get_frontal_face_detector()

# Dlib 人脸预测器
predictor = dlib.shape_predictor("data/data_dlib/shape_predictor_5_face_landmarks.dat")

# Dlib 人脸识别模型
# Face recognition model, the object maps human faces into 128D vectors
facerec = dlib.face_recognition_model_v1("data/data_dlib/dlib_face_recognition_resnet_model_v1.dat")


# 返回单张图像的 128D 特征
def return_128d_features(path_img):
    img = io.imread(path_img)
    img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    faces = detector(img_gray, 1)

    print("检测到人脸的图像：", path_img, "\n")

    # 因为有可能截下来的人脸再去检测，检测不出来人脸了
    # 所以要确保是 检测到人脸的人脸图像 拿去算特征
    if len(faces) != 0:
        shape = predictor(img_gray, faces[0])
        face_descriptor = facerec.compute_face_descriptor(img_gray, shape)
    else:
        face_descriptor = 0
        print("no face")

    # print(face_descriptor)
    return face_descriptor


# 将文件夹中照片特征提取出来, 写入 CSV
#   path_faces_personX:     图像文件夹的路径
#   path_csv_from_photos:   要生成的 CSV 路径

def write_into_csv(path_faces_personX, path_csv_from_photos):
    photos_list = os.listdir(path_faces_personX)
    with open(path_csv_from_photos, "w", newline="") as csvfile:
        writer = csv.writer(csvfile)
        if photos_list:
            for i in range(len(photos_list)):
                # 调用return_128d_features()得到128d特征
                print("正在读的人脸图像：", path_faces_personX + "/" + photos_list[i])
                features_128d = return_128d_features(path_faces_personX + "/" + photos_list[i])
                print(features_128d)
                # 遇到没有检测出人脸的图片跳过
                if features_128d == 0:
                    i += 1
                else:
                    writer.writerow(features_128d)
        else:
            print("Warning: Empty photos in "+path_faces_personX+'/')
            writer.writerow("")


# 读取某人所有的人脸图像的数据，写入 person_X.csv
faces = os.listdir(path_photos_from_camera)
faces.sort()
for person in faces:
    print("##### " + person + " #####")
    print(path_csv_from_photos + person + ".csv")
    write_into_csv(path_photos_from_camera + person, path_csv_from_photos + person + ".csv")
print('\n')


# 从 CSV 中读取数据，计算 128D 特征的均值
def compute_the_mean(path_csv_from_photos):
    column_names = []

    # 128D 特征
    for feature_num in range(128):
        column_names.append("features_" + str(feature_num + 1))

    # 利用 pandas 读取 csv
    rd = pd.read_csv(path_csv_from_photos, names=column_names)

    if rd.size != 0:
        # 存放 128D 特征的均值
        feature_mean_list = []

        for feature_num in range(128):
            tmp_arr = rd["features_" + str(feature_num + 1)]
            tmp_arr = np.array(tmp_arr)
            # 计算某一个特征的均值
            tmp_mean = np.mean(tmp_arr)
            feature_mean_list.append(tmp_mean)
    else:
        feature_mean_list = []
    return feature_mean_list


# 存放所有特征均值的 CSV 的路径
path_csv_from_photos_feature_all = "data/features_all.csv"

# 存放人脸特征的 CSV 的路径
path_csv_from_photos = "data/data_csvs_from_camera/"

with open(path_csv_from_photos_feature_all, "w", newline="") as csvfile:
    writer = csv.writer(csvfile)
    csv_rd = os.listdir(path_csv_from_photos)
    csv_rd.sort()
    print("##### 得到的特征均值 / The generated average values of features stored in: #####")
    for i in range(len(csv_rd)):
        feature_mean_list = compute_the_mean(path_csv_from_photos + csv_rd[i])
        print(path_csv_from_photos + csv_rd[i])
        writer.writerow(feature_mean_list)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

python3 get_features_into_CSV.py
1

这就基本完了，祝你们毕业快乐！