logo

开发者热搜

用Keras和Streamlit构建人脸验证系统：从模型训练到Web部署全流程指南

作者：JC2025.09.18 15:58浏览量：0

简介：本文详细介绍如何使用Keras构建人脸识别模型，并结合Streamlit创建交互式Web应用实现人脸验证功能。内容涵盖数据准备、模型训练、应用开发及部署全流程，提供完整代码示例和优化建议。

一、技术选型与系统架构设计

1.1 Keras与Streamlit的核心优势

Keras作为高级神经网络API，提供简洁的模型构建接口和预训练模型支持，特别适合快速实现人脸识别任务。其优势在于：

  • 丰富的预训练模型库（如VGG16、ResNet50）
  • 便捷的迁移学习接口
  • 高效的GPU加速支持

Streamlit作为轻量级Web框架，具有以下特点：

  • 纯Python开发，无需前端知识
  • 实时重载功能加速开发
  • 丰富的UI组件库
  • 部署简单（支持Heroku、AWS等）

1.2 系统架构

典型架构包含三个模块：

  1. 数据预处理模块：人脸检测与对齐
  2. 特征提取模块：深度学习模型
  3. 验证模块：相似度计算与阈值判断

二、基于Keras的人脸识别模型实现

2.1 环境准备

  1. # 基础环境配置
  2. !pip install tensorflow keras opencv-python streamlit face-recognition
  3. import tensorflow as tf
  4. from tensorflow.keras import layers, models
  5. import cv2
  6. import numpy as np

2.2 数据集准备

推荐使用LFW（Labeled Faces in the Wild）数据集，包含13,233张1680人的人脸图像。数据预处理步骤：

  1. 人脸检测：使用OpenCV的DNN模块

    1. def detect_face(image_path):
    2.  # 加载预训练的人脸检测模型
    3.  prototxt = "deploy.prototxt"
    4.  model = "res10_300x300_ssd_iter_140000.caffemodel"
    5.  net = cv2.dnn.readNetFromCaffe(prototxt, model)
    7.  # 读取并预处理图像
    8.  image = cv2.imread(image_path)
    9.  (h, w) = image.shape[:2]
    10.  blob = cv2.dnn.blobFromImage(cv2.resize(image, (300, 300)), 1.0, 
    11.                              (300, 300), (104.0, 177.0, 123.0))
    13.  # 检测人脸
    14.  net.setInput(blob)
    15.  detections = net.forward()
    17.  # 返回检测到的人脸区域
    18.  if len(detections) > 0:
    19.      i = np.argmax(detections[0, 0, :, 2])
    20.      confidence = detections[0, 0, i, 2]
    21.      if confidence > 0.5:
    22.          box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
    23.          (startX, startY, endX, endY) = box.astype("int")
    24.          return image[startY:endY, startX:endX]
    25.  return None

  2. 数据增强：

    1. from tensorflow.keras.preprocessing.image import ImageDataGenerator
    2. datagen = ImageDataGenerator(
    3.  rotation_range=20,
    4.  width_shift_range=0.2,
    5.  height_shift_range=0.2,
    6.  horizontal_flip=True,
    7.  zoom_range=0.2)

2.3 模型构建

采用Siamese网络架构实现人脸验证：

  1. def build_siamese_model(input_shape=(160, 160, 3)):
  2.     # 基础网络（使用预训练的VGG16）
  3.     base_model = tf.keras.applications.VGG16(
  4.         include_top=False,
  5.         weights='imagenet',
  6.         input_shape=input_shape)
  8.     # 冻结部分层
  9.     for layer in base_model.layers[:-4]:
  10.         layer.trainable = False
  12.     # 定义两个输入分支
  13.     input_a = layers.Input(shape=input_shape)
  14.     input_b = layers.Input(shape=input_shape)
  16.     # 共享权重
  17.     x1 = base_model(input_a)
  18.     x2 = base_model(input_b)
  20.     # 特征扁平化
  21.     x1 = layers.Flatten()(x1)
  22.     x2 = layers.Flatten()(x2)
  24.     # 合并特征
  25.     merged = layers.concatenate([x1, x2])
  27.     # 全连接层
  28.     dense = layers.Dense(4096, activation='relu')(merged)
  29.     dense = layers.Dropout(0.5)(dense)
  30.     dense = layers.Dense(1024, activation='relu')(dense)
  32.     # 输出层
  33.     output = layers.Dense(1, activation='sigmoid')(dense)
  35.     return models.Model([input_a, input_b], output)

2.4 模型训练

训练技巧：

  1. 使用三元组损失（Triplet Loss）或对比损失（Contrastive Loss）
  2. 采用学习率调度器：
    1. lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(
    2.  monitor='val_loss',
    3.  factor=0.1,
    4.  patience=3)
  3. 混合精度训练加速：
    1. policy = tf.keras.mixed_precision.Policy('mixed_float16')
    2. tf.keras.mixed_precision.set_global_policy(policy)

三、Streamlit人脸验证应用开发

3.1 基础界面设计

  1. import streamlit as st
  2. from PIL import Image
  3. import face_recognition
  5. st.title("人脸验证系统")
  6. st.markdown("基于Keras和Streamlit实现")
  8. # 文件上传组件
  9. uploaded_file1 = st.file_uploader("上传第一张人脸照片", type=["jpg", "png"])
  10. uploaded_file2 = st.file_uploader("上传第二张人脸照片", type=["jpg", "png"])

3.2 核心验证逻辑

  1. def verify_faces(img1, img2, threshold=0.6):
  2.     # 加载并编码人脸
  3.     img1_encoding = face_recognition.face_encodings(img1)[0]
  4.     img2_encoding = face_recognition.face_encodings(img2)[0]
  6.     # 计算欧式距离
  7.     distance = face_recognition.face_distance([img1_encoding], img2_encoding)[0]
  9.     # 判断是否为同一人
  10.     return distance < threshold, distance
  12. if uploaded_file1 and uploaded_file2:
  13.     # 读取图像
  14.     image1 = Image.open(uploaded_file1)
  15.     image2 = Image.open(uploaded_file2)
  17.     # 转换为numpy数组
  18.     img1 = np.array(image1.convert('RGB'))
  19.     img2 = np.array(image2.convert('RGB'))
  21.     # 执行验证
  22.     is_match, distance = verify_faces(img1, img2)
  24.     # 显示结果
  25.     col1, col2 = st.columns(2)
  26.     with col1:
  27.         st.image(image1, caption='第一张人脸')
  28.     with col2:
  29.         st.image(image2, caption='第二张人脸')
  31.     st.write(f"验证结果: {'匹配' if is_match else '不匹配'}")
  32.     st.write(f"相似度距离: {distance:.4f}")

3.3 高级功能扩展

  1. 实时摄像头验证：
    ```python
    import cv2
    from streamlit_webrtc import webrtc_streamer

def video_frame_callback(frame):

  1. # 在此实现实时人脸验证逻辑
  2. img = frame.to_ndarray(format="bgr24")
  3. # 人脸检测和验证代码...
  4. return img

st.header(“实时人脸验证”)
webrtc_streamer(key=”face-verification”, video_frame_callback=video_frame_callback)

  2. 2. 数据库集成：
  3. ```python
  4. import sqlite3
  6. # 初始化数据库
  7. conn = sqlite3.connect('faces.db')
  8. c = conn.cursor()
  9. c.execute('''CREATE TABLE IF NOT EXISTS users
  10.              (id INTEGER PRIMARY KEY, name TEXT, encoding BLOB)''')
  12. def save_face_encoding(name, encoding):
  13.     # 将face_recognition的128维编码转换为SQLite可存储格式
  14.     encoding_bytes = encoding.tobytes()
  15.     c.execute("INSERT INTO users (name, encoding) VALUES (?, ?)", 
  16.               (name, encoding_bytes))
  17.     conn.commit()

四、部署与优化

4.1 性能优化策略

  1. 模型量化：

    1. converter = tf.lite.TFLiteConverter.from_keras_model(model)
    2. converter.optimizations = [tf.lite.Optimize.DEFAULT]
    3. tflite_model = converter.convert()

  2. 缓存机制：
    ```python
    from functools import lru_cache

@lru_cache(maxsize=32)
def get_face_encoding(image_path):
image = face_recognition.load_image_file(image_path)
return face_recognition.face_encodings(image)[0]

  2. ## 4.2 部署方案
  3. 1. **本地部署**：
  4. ```bash
  5. streamlit run app.py --server.port 8501
  1. 云部署（Heroku示例）：
  • 创建requirements.txt
  • 创建Procfile：
    1. web: sh setup.sh && streamlit run app.py
  • 使用Heroku CLI部署

4.3 安全考虑

  1. 数据加密：

    1. from cryptography.fernet import Fernet
    2. key = Fernet.generate_key()
    3. cipher_suite = Fernet(key)
    4. encrypted = cipher_suite.encrypt(b"Sensitive face data")

  2. 访问控制：
    ```python
    import streamlit as st

def check_password():
“””Returns True if the user had the correct password.”””

  1. def password_entered():
  2.     """Checks whether a password entered by the user is correct."""
  3.     if st.session_state["password"] == st.secrets["password"]:
  4.         st.session_state["password_correct"] = True
  5.         del st.session_state["password"]  # Don't store the password
  6.     else:
  7.         st.session_state["password_correct"] = False
  9. if "password_correct" not in st.session_state:
  10.     # First run, show input for password
  11.     st.text_input(
  12.         "Password", type="password", on_change=password_entered, key="password"
  13.     )
  14.     return False
  15. elif not st.session_state["password_correct"]:
  16.     # Password not correct, show input + error
  17.     st.text_input(
  18.         "Password", type="password", on_change=password_entered, key="password"
  19.     )
  20.     st.error("😕 Password incorrect")
  21.     return False
  22. else:
  23.     # Password correct.
  24.     return True

if not check_password():
st.stop()

  2. # 五、完整案例实现
  3. ## 5.1 端到端示例代码
  4. ```python
  5. import streamlit as st
  6. import face_recognition
  7. import numpy as np
  8. from PIL import Image
  9. import sqlite3
  10. import os
  12. # 初始化数据库
  13. if not os.path.exists('faces.db'):
  14.     conn = sqlite3.connect('faces.db')
  15.     c = conn.cursor()
  16.     c.execute('''CREATE TABLE users
  17.                  (id INTEGER PRIMARY KEY, name TEXT, encoding BLOB)''')
  18.     conn.commit()
  19.     conn.close()
  21. def main():
  22.     st.title("人脸验证系统")
  24.     menu = ["注册新用户", "人脸验证", "管理用户"]
  25.     choice = st.sidebar.selectbox("菜单", menu)
  27.     if choice == "注册新用户":
  28.         st.subheader("用户注册")
  29.         name = st.text_input("姓名")
  30.         uploaded_file = st.file_uploader("上传人脸照片", type=["jpg", "png"])
  32.         if st.button("注册") and uploaded_file is not None:
  33.             image = Image.open(uploaded_file)
  34.             img_array = np.array(image.convert('RGB'))
  36.             try:
  37.                 encoding = face_recognition.face_encodings(img_array)[0]
  38.                 # 存储到数据库
  39.                 conn = sqlite3.connect('faces.db')
  40.                 c = conn.cursor()
  41.                 c.execute("INSERT INTO users (name, encoding) VALUES (?, ?)", 
  42.                           (name, encoding.tobytes()))
  43.                 conn.commit()
  44.                 conn.close()
  45.                 st.success("用户注册成功")
  46.             except IndexError:
  47.                 st.error("未检测到人脸，请重试")
  49.     elif choice == "人脸验证":
  50.         st.subheader("人脸验证")
  51.         uploaded_file1 = st.file_uploader("上传第一张人脸照片", type=["jpg", "png"])
  52.         uploaded_file2 = st.file_uploader("上传第二张人脸照片", type=["jpg", "png"])
  54.         if uploaded_file1 and uploaded_file2:
  55.             image1 = Image.open(uploaded_file1)
  56.             image2 = Image.open(uploaded_file2)
  57.             img1 = np.array(image1.convert('RGB'))
  58.             img2 = np.array(image2.convert('RGB'))
  60.             try:
  61.                 enc1 = face_recognition.face_encodings(img1)[0]
  62.                 enc2 = face_recognition.face_encodings(img2)[0]
  64.                 distance = face_recognition.face_distance([enc1], enc2)[0]
  65.                 is_match = distance < 0.6
  67.                 col1, col2 = st.columns(2)
  68.                 with col1:
  69.                     st.image(image1, caption='第一张人脸')
  70.                 with col2:
  71.                     st.image(image2, caption='第二张人脸')
  73.                 st.write(f"验证结果: {'匹配' if is_match else '不匹配'}")
  74.                 st.write(f"相似度距离: {distance:.4f}")
  75.             except IndexError:
  76.                 st.error("至少一张图片未检测到人脸")
  78.     elif choice == "管理用户":
  79.         st.subheader("用户管理")
  80.         conn = sqlite3.connect('faces.db')
  81.         c = conn.cursor()
  82.         users = c.execute("SELECT id, name FROM users").fetchall()
  84.         if st.button("显示所有用户"):
  85.             df = pd.DataFrame(users, columns=["ID", "姓名"])
  86.             st.dataframe(df)
  88.         conn.close()
  90. if __name__ == '__main__':
  91.     main()

5.2 运行与测试

  1. 安装依赖：

    1. pip install -r requirements.txt

  2. 运行应用：

    1. streamlit run app.py

  3. 测试流程：

  • 注册新用户（上传照片并输入姓名）
  • 进行人脸验证（上传两张照片）
  • 管理用户数据

六、常见问题与解决方案

6.1 性能问题

问题：验证速度慢
解决方案：

  1. 使用更轻量的模型（如MobileNet）
  2. 实现特征缓存
  3. 使用多线程处理

6.2 准确率问题

问题：误识别率高
解决方案：

  1. 增加训练数据多样性
  2. 调整相似度阈值
  3. 使用多模型集成

6.3 部署问题

问题：Heroku部署失败
解决方案：

  1. 检查Procfile格式
  2. 确保所有依赖在requirements.txt中
  3. 调整构建包大小限制

七、未来发展方向

  1. 3D人脸验证：集成深度传感器数据
  2. 活体检测：防止照片攻击
  3. 多模态验证：结合语音、行为特征
  4. 边缘计算：在移动端实现实时验证

本指南提供了从模型开发到Web部署的完整流程，开发者可根据实际需求调整模型架构和验证阈值。实际应用中建议结合具体场景进行优化，如金融场景需要更高的安全阈值，而社交场景可适当降低阈值以提高用户体验。

相关文章推荐

发表评论

最热文章

关于作者

  • 被阅读数
  • 被赞数
  • 被收藏数