驾驶员嗜睡分类 - 深度学习

资讯 2年前

1.28K

瞌睡检测是一种汽车安全技术，有助于防止驾驶员在驾驶时睡着了造成的事故。根据 NHTSA（美国国家公路交通安全管理局）的数据，警方报告的 91，000 起车祸涉及疲劳驾驶。这些车祸导致 2017 年估计有 50，000 人受伤和近 800 人死亡

瞌睡检测是一种汽车安全技术，有助于防止驾驶员在驾驶时睡着了造成的事故。根据 NHTSA（美国国家公路交通安全管理局）的数据，警方报告的 91，000 起车祸涉及疲劳驾驶。这些车祸导致 2017 年估计有 50，000 人受伤和近 800 人死亡。目前，方法主要集中在使用深度学习或机器学习技术进行眨眼检测，但是，如果司机戴墨镜怎么办？

如果我们同时考虑驾驶员的头部倾斜、打哈欠和其他因素会怎样？是的，这正是本文所做的。

在进入特征提取部分之前，从“ULg 多模态嗜睡数据库”（也称为DROZY ）中获取数据，该数据库包含各种类型的嗜睡相关数据（信号、图像等）。

该数据集包含大约 45 个视频剪辑，这些剪辑按照卡罗林斯卡嗜睡量表（KSS）进行标记。KSS 量表范围从 1 到 9，其中 1 表示非常警觉，9 表示非常困。

由于该数据集中缺少数据和标签，因此将标签从 1－9 转换为 1－3，分别表示无嗜睡、中度嗜睡和高度嗜睡。本来会使用视频分类过程，但由于数据不够，先提取特征并将它们用作我的模型输入。这样，模型将使用更少的数据达到更准确的效果。

特征提取

对于这个特定任务，我将使用 TensorFlow－GPU 2．6 和 python 3．6 以及使用 pip 预安装的库 open－cv、dlib、scipy。

特征提取所需的所有库：

from scipy．spatial import distance as dist

from imutils．video import FileVideoStream

from imutils．video import VideoStream

from imutils import face＿utils

import numpy as np

import argparse

import imutils

import time

import dlib

import cv2

import datetime

import csv

import os

import math

平均眨眼持续时间：眼睛纵横比低于 0．3 然后高于 0．3 的持续时间被检测为眨眼。眨眼发生的时间称为眨眼持续时间。平均每分钟眨眼持续时间以计算平均眨眼持续时间。

＃ grab the indexes of the facial landmarks for the left and

＃ right eye， respectively

（lStart， lEnd）＝ face＿utils．FACIAL＿LANDMARKS＿IDXS［＂left＿eye＂］

（rStart， rEnd）＝ face＿utils．FACIAL＿LANDMARKS＿IDXS［＂right＿eye＂］

def eye＿aspect＿ratio（eye）：

A ＝ dist．euclidean（eye［1］， eye［5］）

B ＝ dist．euclidean（eye［2］， eye［4］）

C ＝ dist．euclidean（eye［0］， eye［3］）

ear ＝（A ＋ B）／（2．0 ＊ C）

return ear

眨眼频率：每分钟眨眼的次数称为眨眼频率。

def time＿difference（start＿time， end＿time）：

start＿time ＝ start＿time．split（）

for i in range（0，8）：

hours ＝ int（start＿time［3］）

mins ＝ int（start＿time［4］）

secs ＝ int（start＿time［5］）

milisecs ＝ int（start＿time［6］）

microsecs ＝ int（start＿time［7］）

＃converting it to microsecs

t1， m1， s1， ms1， mis1 ＝ hours， mins， secs， milisecs， microsecs

start＿time＿microsecs ＝ mis1 ＋ 1000＊（ms1 ＋ 1000＊（s1 ＋ 60＊（m1 ＋ 60＊t1）））

end＿time ＝ end＿time．split（）

for x in range（0，8，1）：

hours ＝ int（end＿time［3］）

mins ＝ int（end＿time［4］）

secs ＝ int（end＿time［5］）

milisecs ＝ int（end＿time［6］）

microsecs ＝ int（end＿time［7］）

t2， m2， s2， ms2， mis2 ＝ hours， mins， secs， milisecs， microsecs
end＿time＿microsecs ＝ mis2 ＋ 1000＊（ms2 ＋ 1000＊（s2 ＋ 60＊（m2 ＋ 60＊t2）））

＃finding the duration of blink

time＿differ ＝ end＿time＿microsecs － start＿time＿microsecs

＃print ＇time＿difference in microsecs ＝＇， time＿differ

return time＿differ

嘴部纵横比：计算 MAR 以检测一个人是否在打哈欠。

（omouth， emouth）＝ face＿utils．FACIAL＿LANDMARKS＿IDXS［＂mouth＂］

def mouth＿aspect＿ratio（mouth）：

＃ compute the euclidean distances between the two sets of

＃ vertical mouth landmarks （x， y）－coordinates

A ＝ dist．euclidean（mouth［2］， mouth［10］）＃ 51， 59

B ＝ dist．euclidean（mouth［4］， mouth［8］）＃ 53， 57

＃ compute the euclidean distance between the horizontal

＃ mouth landmark （x， y）－coordinates

C ＝ dist．euclidean（mouth［0］， mouth［6］）＃ 49， 55

＃ compute the mouth aspect ratio

mar ＝（A ＋ B）／（2．0 ＊ C）

＃ return the mouth aspect ratio

return mar

头部姿态：每帧计算不同的角度，得到头部的姿态。

def getHeadTiltAndCoords（size， image＿points， frame＿height）：

focal＿length ＝ size［1］

center ＝（size［1］／2， size［0］／2）

camera＿matrix ＝ np．array（［［focal＿length， 0， center［0］］，［

0， focal＿length， center［1］］，［0， 0， 1］］， dtype＝＂double＂）

dist＿coeffs ＝ np．zeros（（4， 1））＃ Assuming no lens distortion

（＿， rotation＿vector， translation＿vector）＝ cv2．solvePnP（model＿points， image＿points，
camera＿matrix， dist＿coeffs，
flags ＝ cv2．SOLVEPNP＿ITERATIVE）＃ flags＝cv2．CV＿ITERATIVE）

（nose＿end＿point2D，＿）＝ cv2．projectPoints（np．array（

［（0．0， 0．0， 1000．0）］）， rotation＿vector， translation＿vector， camera＿matrix， dist＿coeffs）

＃get rotation matrix from the rotation vector

rotation＿matrix，＿＝ cv2．Rodrigues（rotation＿vector）

＃calculate head tilt angle in degrees

head＿tilt＿degree ＝ abs（

［－180］－ np．rad2deg（［rotationMatrixToEulerAngles（rotation＿matrix）［0］］））

＃calculate starting and ending points for the two lines for illustration

starting＿point ＝（int（image＿points［0］［0］）， int（image＿points［0］［1］））

ending＿point ＝（int（nose＿end＿point2D［0］［0］［0］）， int（nose＿end＿point2D［0］［0］［1］））

ending＿point＿alternate ＝（ending＿point［0］， frame＿height ／／ 2）

return head＿tilt＿degree， starting＿point， ending＿point， ending＿point＿alternate

这就是我的特征提取过程中的样子。

是时候制作模型了！

由于我们已经完成了特征选择部分，我们不必构建复杂的模型。我将使用人工神经网络

import numpy as np

import sklearn

from sklearn import preprocessing

＃from sklearn．datasets．samples＿generator import make＿blobs

＃from sklearn．preprocessing import LabelEncoder， StandardScaler

import csv

import os

from tensorflow import keras

import random

from keras．models import Sequential

from keras．layers import Dense ， Dropout， Activation， BatchNormalization

from keras import regularizers

importmatplotlib．pyplot as plt

＃from keras．utils import plot＿model

import sklearn

from sklearn．metrics import chaos＿matrix

from sklearn．metrics import accuracy＿score

from sklearn．metrics import classification＿report

import pickle

from keras．utils import np＿utils

from keras import optimizers

from keras．models import load＿model

这是深度学习中最简单的模型的设计，但由于特征提取而有效。因为我们计算的是每分钟的瞌睡程度，所以要确保你将你的输入连接起来，然后传递给模型。

＃designing the model

model＝Sequential（）

model．add（Dense（64， input＿dim＝6， activation＝＇relu＇））

model．add（Dropout（0．001））

model．add（Dense（64， input＿dim＝6， activation＝＇relu＇））

model．add（Dropout（0．001））

model．add（Dense（32， input＿dim＝6， activation＝＇relu＇））

model．add（Dense（16， input＿dim＝6， activation＝＇relu＇））

model．add（Dense（4， activation＝＇softmax＇， use＿bias＝False））

＃compile the model

＃adam ＝ keras．optimizers．Adam（lr＝0．01）

adam ＝ keras．optimizers．Adam（lr＝0．001）

model．compile（loss＝＇categorical＿crossentropy＇， optimizer＝adam， metrics＝［＇accuracy＇］）

＃fit the model

checkpoint ＝ keras．callbacks．ModelCheckpoint（filepath＝＂trained＿models／DrowDet＿model（output4）．hdf5＂， period＝1）

tbCallBack ＝ keras．callbacks．TensorBoard（log＿dir＝＇．／scalar＇，

histogram＿freq＝0， write＿graph＝True， write＿images＝True）
history＝model．fit（Xtrain， Ytrain， epochs＝50， batch＿size＝256， callbacks＝［checkpoint， tbCallBack］， validation＿data＝（Xval，Yval））

使用准确性与验证准确性和训练损失与验证损失的模型性能。