conda install py-opencv -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install dlib==19.7.0 -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install face_recognition -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install Pillow -i https://pypi.tuna.tsinghua.edu.cn/simple

La descarga e importación del kit de herramientas está completa, y lo siguiente es la construcción y operación del proyecto

3. Construcción y prueba de modelo de reconocimiento facial basado en red neuronal convolucional

1. Código central

Paso 1: recopile datos de rasgos faciales suyos y de otros, correspondientes a las etiquetas de datos 0 y 1 respectivamente

get_my_face.py

import cv2
import dlib
import os
import random

output_dir = './my_crop_faces'
size = 160
if not os.path.exists(output_dir):
    os.makedirs(output_dir)

# 改变图片的亮度与对比度
def relight(img, light=1, bias=0):
    w = img.shape[1]
    h = img.shape[0]
    #image = []
    for i in range(0,w):
        for j in range(0,h):
            for c in range(3):
                tmp = int(img[j,i,c]*light + bias)
                if tmp > 255:
                    tmp = 255
                elif tmp < 0:
                    tmp = 0
                img[j,i,c] = tmp
    return img

#使用dlib自带的frontal_face_detector作为我们的特征提取器
detector = dlib.get_frontal_face_detector()
# 打开摄像头 参数为输入流，可以为摄像头或视频文件
camera = cv2.VideoCapture(0)

index = 0
while True:
    if (index <= 1000):
        print('Being processed picture %s' % index)
        # 从摄像头读取照片
        success, img = camera.read()
        # 转为灰度图片
        gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        # 使用detector进行人脸检测
        dets = detector(gray_img, 1)

        for i, d in enumerate(dets):
            x1 = d.top() if d.top() > 0 else 0
            y1 = d.bottom() if d.bottom() > 0 else 0
            x2 = d.left() if d.left() > 0 else 0
            y2 = d.right() if d.right() > 0 else 0

            face = img[x1:y1,x2:y2]
            # 调整图片的对比度与亮度， 对比度与亮度值都取随机数，这样能增加样本的多样性
            face = relight(face, random.uniform(0.5, 1.5), random.randint(-50, 50))
            face = cv2.resize(face, (size,size))
            cv2.imshow('image', face)
            cv2.imwrite(output_dir+'/'+str(index)+'.jpg', face)
            index += 1
        key = cv2.waitKey(30) & 0xff
        if key == 27:
            break
    else:
        print('Finished!')
        break

Paso 2: entrene un modelo que reconozca los rasgos faciales y guarde el modelo como un archivo en formato .h5

modelo_tren.py

#-*- coding: utf-8 -*-
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Convolution2D, MaxPooling2D
from keras.optimizers import SGD
from keras.utils import np_utils
import os
import cv2
import numpy as np
from sklearn.model_selection import train_test_split
import random

def get_files(input_dir):
    file_list = []
    for (path, dirnames, filenames) in os.walk(input_dir):
        # print(path) #输出对应顶层文件夹
        # print(dirnames)#在当前文件夹下的文件夹
        # print(filenames)#在当前文件夹下的文件夹
        for filename in filenames:
            if filename.endswith('.jpg') or filename.endswith('.bmp'):
                # print(filename)
                full_path = os.path.join(path, filename)
                # print(full_path)
                file_list.append(full_path)
    return file_list

#设置hujianhua文件夹的对应标签为0
def getPaddingSize(img):
    h, w, _ = img.shape
    top, bottom, left, right = (0,0,0,0)
    longest = max(h, w)

    if w < longest:
        tmp = longest - w
        # //表示整除符号
        left = tmp // 2
        right = tmp - left
    elif h < longest:
        tmp = longest - h
        top = tmp // 2
        bottom = tmp - top
    else:
        pass
    return top, bottom, left, right

def read_img_label(file_list, label):
    size = 64
    imgs = []
    labs = []
    #01
    num = 0
    for filename in file_list:
        # print(filename)
        img = cv2.imread(filename)
        # print(img.shape)
        top, bottom, left, right = getPaddingSize(img)
        # 将图片放大， 扩充图片边缘部分
        img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=[0, 0, 0])
        img = cv2.resize(img, (size, size))
        imgs.append(img)
        labs.append(label)
        num = num + 1

    # print(len(imgs))
    # print(len(labs))
    return imgs, labs


def read_dataset():
    input_dir = "./data_collection/my_crop_faces"


    all_imgs_list = []
    all_label_list = []
    my_file_list = get_files(input_dir)
    # 0->[0,1] 1->[1,0]
    label = 0 #[0, 1]
    my_imgs_list, my_labs_list = read_img_label(my_file_list, label)

    input_dir = "./data_collection/others_img_crop"

    others_file_list = get_files(input_dir)
    label = 1 #[1, 0] #->0
    others_imgs_list, others_labs_list = read_img_label(others_file_list, label)

    for img in my_imgs_list:
        all_imgs_list.append(img)
    for img in others_imgs_list:
        all_imgs_list.append(img)

    for label in my_labs_list:
        all_label_list.append(label)
    for label in others_labs_list:
        all_label_list.append(label)

    imgs_array = np.array(all_imgs_list)
    # print(imgs_array.shape)

    labs_array = np.array(all_label_list)
    # print(labs_array.shape)

    return imgs_array,labs_array


#加载数据集并按照交叉验证的原则划分数据集并进行相关预处理工作
def load_data(img_rows = 64, img_cols = 64,
         img_channels = 3, nb_classes = 2):
    #加载数据集到内存
    images, labels = read_dataset()
    print(images.shape)
    print(labels.shape)

    train_images, valid_images, train_labels, valid_labels = train_test_split(images, labels, test_size = 0.3, random_state = random.randint(0, 100))
    _, test_images, _, test_labels = train_test_split(images, labels, test_size = 0.5, random_state = random.randint(0, 100))

    train_images = train_images.reshape(train_images.shape[0], img_rows, img_cols, img_channels)
    valid_images = valid_images.reshape(valid_images.shape[0], img_rows, img_cols, img_channels)
    test_images = test_images.reshape(test_images.shape[0], img_rows, img_cols, img_channels)
    input_shape = (img_rows, img_cols, img_channels)

    #输出训练集、验证集、测试集的数量
    print(train_images.shape[0], 'train samples')
    print(valid_images.shape[0], 'valid samples')
    print(test_images.shape[0], 'test samples')

    #我们的模型使用categorical_crossentropy作为损失函数，因此需要根据类别数量nb_classes将
    #类别标签进行one-hot编码使其向量化，在这里我们的类别只有两种，经过转化后标签数据变为二维
    train_labels = np_utils.to_categorical(train_labels, nb_classes)
    valid_labels = np_utils.to_categorical(valid_labels, nb_classes)
    test_labels = np_utils.to_categorical(test_labels, nb_classes)
    print(train_labels.shape)
    print(valid_labels.shape)
    print(test_labels.shape)
    #像素数据浮点化以便归一化
    train_images = train_images.astype('float32')
    valid_images = valid_images.astype('float32')
    test_images = test_images.astype('float32')

    #将其归一化,图像的各像素值归一化到0~1区间
    train_images /= 255
    valid_images /= 255
    test_images /= 255

    return train_images, train_labels, valid_images, valid_labels, test_images, test_labels

#建立模型
def build_model(nb_classes = 2):
    #构建一个空的网络模型，它是一个线性堆叠模型，各神经网络层会被顺序添加，专业名称为序贯模型或线性堆叠模型
    model = Sequential()

    #以下代码将顺序添加CNN网络需要的各层，一个add就是一个网络层
    model.add(Convolution2D(32, 3, 3, border_mode='same',
                                 input_shape =  (64, 64, 3)))    #1 2维卷积层
    model.add(Activation('relu'))                                  #2 激活函数层

    model.add(Convolution2D(32, 3, 3))                             #3 2维卷积层
    model.add(Activation('relu'))                                  #4 激活函数层

    model.add(MaxPooling2D(pool_size=(2, 2)))                      #5 池化层
    model.add(Dropout(0.25))                                       #6 Dropout层

    model.add(Convolution2D(64, 3, 3, border_mode='same'))         #7  2维卷积层
    model.add(Activation('relu'))                                  #8  激活函数层

    model.add(Convolution2D(64, 3, 3))                             #9  2维卷积层
    model.add(Activation('relu'))                                  #10 激活函数层

    model.add(MaxPooling2D(pool_size=(2, 2)))                      #11 池化层
    model.add(Dropout(0.25))                                       #12 Dropout层

    model.add(Flatten())                                           #13 Flatten层
    model.add(Dense(512))                                          #14 Dense层,又被称作全连接层
    model.add(Activation('relu'))                                  #15 激活函数层
    model.add(Dropout(0.5))                                        #16 Dropout层
    model.add(Dense(nb_classes))                                   #17 Dense层
    model.add(Activation('softmax'))                               #18 分类层，输出最终结果
    #输出模型概况
    print(model.summary())
    return model

model = build_model()

sgd = SGD(lr=0.01, decay=1e-6,
          momentum=0.9, nesterov=True)  # 采用SGD+momentum的优化器进行训练，首先生成一个优化器对象
model.compile(loss='categorical_crossentropy',
                   optimizer=sgd,
                   metrics=['accuracy'])  # 完成实际的模型配置工作

train_images, train_labels, valid_images, valid_labels, test_images, test_labels = load_data()

batch_size = 20
nb_epoch = 10
train_history = model.fit(train_images,
               train_labels,
               batch_size=batch_size,
               nb_epoch=nb_epoch,
               validation_data=(valid_images, valid_labels),
               shuffle=True)

scores = model.evaluate(test_images, test_labels)
print('accuracy=', scores[1])
prediction = model.predict_classes(test_images)
# print(prediction)
model.save('./me.face.model.h5')

Paso 3: lea el modelo de reconocimiento facial en el formato de archivo .h5 y reconozca las imágenes faciales grabadas por la cámara

video_predict.py

import cv2
import dlib
from keras.models import load_model
import sys

size = 64

# 使用dlib自带的frontal_face_detector作为我们的特征提取器
detector = dlib.get_frontal_face_detector()

cam = cv2.VideoCapture(0)

model = load_model('./me.face.model.h5')

while True:
    _, img = cam.read()
    gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    dets = detector(gray_image, 1)
    for i, d in enumerate(dets):
        x1 = d.top() if d.top() > 0 else 0
        y1 = d.bottom() if d.bottom() > 0 else 0
        x2 = d.left() if d.left() > 0 else 0
        y2 = d.right() if d.right() > 0 else 0
        face = img[x1:y1, x2:y2]
        # 调整图片的尺寸
        face = cv2.resize(face, (size, size))
        shape_img = (face.reshape(1, size, size, 3)).astype('float32') / 255

        prediction = model.predict_classes(shape_img)
        print(prediction[0])
        name = "unknown"
        if prediction[0] == 0:
            print("识别出本人")
            name = "Aricl."
        else:
            print("不是本人")
            name = "unknown"
        cv2.rectangle(img, (x2, x1), (y2, y1), (255, 0, 0), 3)
        font = cv2.FONT_HERSHEY_SIMPLEX
        cv2.putText(img, name, (x2, x1), font, 0.8, (255, 255, 255), 1)

    cv2.imshow('image', img)
    key = cv2.waitKey(30) & 0xff
    if key == 27:
        sys.exit(0)

2. Principios básicos del reconocimiento

        Uno de los principales es usar OpenCV (Biblioteca de visión por computadora de código abierto) , que es una biblioteca de visión por computadora de código abierto para el procesamiento de imágenes.

Es un conjunto de bibliotecas de funciones API de código abierto         sobre visión artificial . Esto significa que (1) ya sea una investigación científica o una aplicación comercial, se puede usar para el desarrollo; (2) el código fuente de todas las funciones de la API es público y puede ver los pasos del programa de su implementación interna; ( 3 ) Puede modificar el código fuente de OpenCV para compilar y generar las funciones API específicas que necesita. Sin embargo, como biblioteca, lo que proporciona es solo la API de algunos algoritmos clásicos, populares y de uso común.

        Un algoritmo típico de visión por computadora generalmente incluye los siguientes pasos:

recopilación de datos

preprocesamiento

extracción de características

selección de características

Diseño y entrenamiento de clasificadores

Clasificación

Para estas seis partes, OpenCV proporciona API para que los desarrolladores llamen.

        El segundo núcleo es usar Keras para construir una red neuronal convolucional .

        Keras es un marco de entrada relativamente bueno para la inteligencia artificial. Es un marco de red neuronal Python avanzado que se agregó a TensorFlow como su marco predeterminado, lo que proporciona una API más avanzada para TensorFlow.

        Si TensorFlow se compara con Java o C++ en el mundo de la programación, entonces Keras es Python en el mundo de la programación. Como paquete de alto nivel de TensorFlow , se puede usar junto con TensorFlow para construir modelos rápidamente.

        Y Keras cuenta con el respaldo oficial de TensorFlow. Cuando hay una GPU disponible en la máquina, el código llamará automáticamente a la GPU para computación paralela, ¡lo cual es muy poderoso!

3. Ejecutar y probar

Paso 1: recopile datos de rasgos faciales suyos y de otros (tenga en cuenta que debe encender la cámara de la computadora; de lo contrario, se informará un error).

Paso 2: Realice 10 rondas de entrenamiento del modelo de datos faciales

Paso 3: prueba de comparación y reconocimiento facial

La imagen de arriba soy yo (blogger Aricl.), y la imagen de abajo es mi compañero de cuarto (rostro desconocido). ¡Se puede ver que la precisión del reconocimiento facial sigue siendo buena!

4. Análisis y Resumen

Esta vez, al construir un modelo de reconocimiento facial basado en la red neuronal convolucional y Keras , el principio básico de implementación es: consulte la biblioteca OpenCV en Python , llame al clasificador de rostros y luego llame a la cámara de la computadora para leer un solo cuadro . datos en un bucle Realice la detección de rostros en tiempo real, encuadre el rostro y marque la información.

En primer lugar, necesitamos recopilar datos faciales. Se han recopilado un total de 1,000 piezas de datos de características faciales de la persona y otros. Una vez que se completa la recopilación, se entrena el modelo de datos. Se realizan un total de 10 rondas de entrenamiento. , con más de 6000 rondas de entrenamiento. Los buenos modelos se guardan como archivos en formato .h5 . Luego llame a la cámara para leer la foto de la cara de cada cuadro, escalar la imagen en gris, detectar la cara y encuadrar el área correspondiente, leer el archivo de modelo de reconocimiento facial .h5 para el reconocimiento y comparación de rostros, y marcar la información anterior como personal o desconocida.

Además, al recolectar, existen ciertos requisitos para la persona y el entorno que se recolectarán. La luz debe ser brillante para que la cámara pueda ver la cara claramente, y la cara debe estar frente a la cámara , para que la característica facial recolectada los datos son más precisos y el efecto de reconocimiento es mejor .

Esta vez es solo una introducción preliminar al reconocimiento facial, y tengo un gran interés en aprenderlo, pero el blogger se está preparando para el examen de ingreso de posgrado, por lo que solo puedo obtener una comprensión preliminar. Continuaré aprendiendo e investigando tecnologías relacionadas. en este campo cuando tengo la oportunidad, vamos! !

artículo de referencia

Python+Keras+opencv realiza el reconocimiento de rostros %84%E5%BB%BA%E4%BA%BA%E8%84%B8%E8%AF%86%E5%88%AB%E6%A8%A1%E5%9E%8B&utm_medium=distribute.pc_search_result ninguno -task-blog-2~all~sobaiduweb~default-3-91038858.nonecase&spm=1018.2226.3001.4187 serie de implementación de python de reconocimiento y detección de rostros (5) - use la biblioteca keras para entrenar el modelo de reconocimiento de rostroshttps://blog.csdn.net/weixin_44491431/article/details/113839543?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522168601107216800185824691%2522%252C %2522s cm%2522%253A%252220140713.130102334..%2522%257D&request_id = 168601107216800185824691 %E4%BD%BF % E7%94%A8Keras%E6%9E%84%E5%BB%BA%E4%BA%BA%E8%84%B8%E8%AF%86%E5%88%AB%E6%A8%A1%E5 % 9E%8B&spm=1018.2226.3001.4187 le enseñará a usar Keras para la detección y el reconocimiento de rostroshttps://blog.csdn.net/m0_55479420/article/details/115268470?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522168601107216800185824691%2522%252C%2522scm% 2522%253A%252220140713.130102334..%2522%257D&request_id = 168601107216800185824691 %E4%BD%BF% E7%94%A8Keras%E6%9E%84%E5%BB%BA%E4%BA%BA%E8%84%B8%E8%AF%86%E5%88%AB%E6%A8%A1%E5% 9E%8B&spm=1018.2226.3001.4187

[Introducción al caso de aprendizaje profundo 2] Construcción de un modelo de reconocimiento facial basado en una red neuronal convolucional y Keras

Directorio de artículos

1. Herramientas y entorno

2. Construcción de un entorno de aprendizaje profundo