自拍亚洲一区欧美另类,激情久久av一区av二区,国产日本欧美

駕駛員嗜睡分類 - 深度學習

2022-10-08 14:32

瞌睡檢測是一種汽車安全技術，有助于防止駕駛員在駕駛時睡著了造成的事故。根據 NHTSA（美國國家公路交通安全管理局）的數(shù)據，警方報告的 91，000 起車禍涉及疲勞駕駛。這些車禍導致 2017 年估計有 50，000 人受傷和近 800 人死亡。目前，方法主要集中在使用深度學習或機器學習技術進行眨眼檢測，但是，如果司機戴墨鏡怎么辦？

如果我們同時考慮駕駛員的頭部傾斜、打哈欠和其他因素會怎樣？是的，這正是本文所做的。

在進入特征提取部分之前，從“ULg 多模態(tài)嗜睡數(shù)據庫”（也稱為DROZY ）中獲取數(shù)據，該數(shù)據庫包含各種類型的嗜睡相關數(shù)據（信號、圖像等）。

該數(shù)據集包含大約 45 個視頻剪輯，這些剪輯按照卡羅林斯卡嗜睡量表（KSS）進行標記。KSS 量表范圍從 1 到 9，其中 1 表示非常警覺，9 表示非常困。

由于該數(shù)據集中缺少數(shù)據和標簽，因此將標簽從 1－9 轉換為 1－3，分別表示無嗜睡、中度嗜睡和高度嗜睡。本來會使用視頻分類過程，但由于數(shù)據不夠，先提取特征并將它們用作我的模型輸入。這樣，模型將使用更少的數(shù)據達到更準確的效果。

特征提取

對于這個特定任務，我將使用 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

平均眨眼持續(xù)時間：眼睛縱橫比低于 0．3 然后高于 0．3 的持續(xù)時間被檢測為眨眼。眨眼發(fā)生的時間稱為眨眼持續(xù)時間。平均每分鐘眨眼持續(xù)時間以計算平均眨眼持續(xù)時間。

＃ 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

眨眼頻率：每分鐘眨眼的次數(shù)稱為眨眼頻率。

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

頭部姿態(tài)：每幀計算不同的角度，得到頭部的姿態(tài)。

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））

使用準確性與驗證準確性和訓練損失與驗證損失的模型性能。