Progetto Face Detection in Python [in 5 semplici passaggi]

L'identificazione degli oggetti e il rilevamento dei volti sono probabilmente le applicazioni più popolari della visione artificiale. Questa tecnologia trova applicazioni in vari settori, come la sicurezza e i social media. Quindi stiamo costruendo un progetto di rilevamento dei volti tramite Python.

Nota che dovresti avere familiarità con la programmazione in Python, OpenCV e NumPy. Ti assicurerà di non confonderti mentre lavori a questo progetto. Iniziamo.

Abbiamo condiviso due metodi per eseguire il riconoscimento facciale. Il primo utilizza la libreria di riconoscimento facciale di Python, mentre l'altro utilizza OpenCV e NumPy. Dai un'occhiata ai nostri programmi di scienza dei dati per saperne di più.

Riconoscimento facciale con il "riconoscimento facciale" di Python

Probabilmente il metodo più semplice per rilevare i volti è utilizzare la libreria di riconoscimento facciale in Python . Aveva una precisione del 99,38% nel database LFW. Usarlo è abbastanza semplice e non richiede molto sforzo. Inoltre, la libreria dispone di un comando dedicato 'face_recognition' per identificare i volti nelle immagini.

Come utilizzare il riconoscimento facciale

Puoi distinguere i volti nelle immagini usando il comando 'face_locations':

importa riconoscimento_faccia

immagine = face_recognition.load_image_file ("il tuo_file.jpg")

face_locations = face_recognition.face_locations(immagine)

Può anche riconoscere i volti e associarli ai loro nomi:

importa riconoscimento_faccia

immagine_nota = face_recognition.load_image_file(“modi.jpg”)

immagine_sconosciuta = face_recognition.load_image_file ("sconosciuto.jpg")

modi_encoding = face_recognition.face_encodings(immagine_nota)[0]

codifica_sconosciuta = face_recognition.face_encodings(immagine_sconosciuta)[0]

risultati = face_recognition.compare_faces([modi_encoding], unknown_encoding)

L'immagine contiene "Narendra Modi"

Ci sono molte altre cose che puoi eseguire con questa libreria combinandola con altre. Discuteremo ora dell'esecuzione del riconoscimento facciale con altre importanti librerie in Python, in particolare OpenCV e NumPy.

Leggi di più: Python NumPy Tutorial: impara Python Numpy con esempi

Progetto Face Detection in Python

In questo progetto, abbiamo eseguito il rilevamento e il riconoscimento dei volti utilizzando OpenCV e NumPy. Abbiamo usato Raspberry Pi, ma puoi usarlo anche con altri sistemi. Dovrai solo modificare leggermente il codice per usarlo su qualche altro dispositivo (come un Mac o un PC Windows).

Un po' di merito per questo progetto va a Marcelo Rovai .

Passaggio 1: installa le librerie

Innanzitutto, dovresti installare le librerie richieste, OpenCV e NumPy. Puoi installarlo facilmente tramite:

pip installa opencv-python

pip installa opencv-contrib-python

Per installare NumPy nel tuo sistema, usa lo stesso comando di cui sopra e sostituisci 'opencv-python' con 'numpy':

pip install numpy

Passaggio 2: rileva i volti

Ora devi configurare la tua videocamera e collegarla al tuo sistema. La fotocamera dovrebbe funzionare correttamente per evitare problemi di rilevamento dei volti.

Prima che la nostra fotocamera ci riconosca, deve prima rilevare i volti. Useremo il classificatore Haar Cascade per il rilevamento dei volti. È principalmente un metodo di rilevamento di oggetti in cui si addestra una funzione a cascata attraverso immagini negative e positive, dopodiché diventa in grado di rilevare oggetti in altre foto.

Nel nostro caso, vogliamo che il nostro modello rilevi i volti. OpenCV viene fornito con un trainer e un rilevatore, quindi l'utilizzo del classificatore Haar Cascade è relativamente più comodo con questa libreria. Puoi creare il tuo classificatore per rilevare anche altre immagini.

Ecco il codice:

importa numpy come np

importa cv2

faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')

cap = cv2.VideoCapture(0)

cap.set(3,640) # set Larghezza

cap.set(4.480) # set Altezza

mentre Vero:

ret, img = cap.read()

img = cv2.flip(img, -1)

grigio = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

facce = faceCascade.detectMultiScale(

grigio,

fattore di scala = 1,2,

minNeighbors=5,

Dimensione min=(20, 20)

)

per (x,y,w,h) in facce:

cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)

roi_gray = grigio[y:y+h, x:x+w]

colore_roi = img[y:y+h, x:x+w]

cv2.imshow('video',img)

k = cv2.waitKey(30) & 0xff

se k == 27: # premere 'ESC' per uscire

rottura

cap.release()

cv2.destroyAllWindows()

Passaggio 3: raccogliere dati

Ora che il tuo modello è in grado di identificare i volti, puoi addestrarlo in modo che inizi a riconoscere il viso nell'immagine. Per farlo, devi fornirgli più foto dei volti che vuoi che ricordi.

Ecco perché inizieremo con la creazione del nostro set di dati raccogliendo foto. Dopo aver raccolto le immagini necessarie, aggiungi gli ID per ogni persona, in modo che la modella sappia quale faccia associare a quale ID. Inizia con le immagini di una persona e aggiungi almeno 10-20. Usa espressioni diverse per ottenere i risultati più efficaci.

Crea uno script per aggiungere ID utente alle immagini, in modo da non doverlo fare manualmente ogni volta. Lo script è fondamentale nel caso in cui desideri utilizzare il tuo modello per più facce.

Impara i corsi di Machine Learning dalle migliori università del mondo. Guadagna master, Executive PGP o programmi di certificazione avanzati per accelerare la tua carriera.

Passaggio 4: allenarsi

Dopo aver creato il set di dati delle immagini della persona, dovresti addestrare il modello. Invierai le immagini al tuo riconoscitore OpenCV e alla fine creerà un file chiamato "trainer.yml".

In questa fase, devi solo fornire al modello le immagini e i relativi ID in modo che il modello possa familiarizzare con l'ID di ogni immagine. Dopo aver finito di addestrare il modello, possiamo testarlo.

Ecco il codice:

importa cv2

importa numpy come np

dall'immagine di importazione PIL

importare os

# Percorso per il database delle immagini dei volti

percorso = 'set di dati'

riconoscimento = cv2.face.LBPHFaceRecognizer_create()

rivelatore = cv2.CascadeClassifier(“haarcascade_frontalface_default.xml”);

# funzione per ottenere le immagini e i dati dell'etichetta

def getImagesAndLabels(percorso):

imagePaths = [os.path.join(percorso,f) for f in os.listdir(percorso)]

faceSamples=[]

ID = []

per imagePath in imagePaths:

PIL_img = Image.open(imagePath).convert('L') # scala di grigi

img_numpy = np.array(PIL_img,'uint8')

id = int(os.path.split(imagePath)[-1].split(“.”)[1])

facce = detector.detectMultiScale(img_numpy)

per (x,y,w,h) in facce:

faceSamples.append(img_numpy[y:y+h,x:x+w])

ids.append(id)

restituisce faceSamples, id

print ("\n [INFO] Volti di allenamento. Ci vorranno alcuni secondi. Attendi ...")

facce, ID = getImagesAndLabels (percorso)

Recognitor.train(faces, np.array(ids))

# Salva il modello in trainer/trainer.yml

riconoscitore.write('trainer/trainer.yml')

# Stampa il numero di volti allenati e termina il programma

print(“\n [INFO] {0} facce addestrate. Uscita dal programma”.format(len(np.unique(ids))))

Impara: l'applicazione MATLAB nel riconoscimento facciale: codice, descrizione e sintassi

Passaggio n. 5: avvia il riconoscimento

Ora che hai addestrato il modello, possiamo iniziare a testare il modello. In questa sezione, abbiamo aggiunto nomi agli ID in modo che il modello possa visualizzare i nomi dei rispettivi utenti che riconosce.

Il modello non riconosce una persona. Prevede se il viso che rileva corrisponde al viso presente nel suo database. Il nostro modello mostra una percentuale di quanto il viso corrisponde al viso presente nel suo database. La sua precisione dipenderà fortemente dall'immagine che stai testando e dalle immagini che hai aggiunto al tuo database (le immagini con cui hai addestrato il modello).

Ecco il codice:

importa cv2

importa numpy come np

importare os

riconoscimento = cv2.face.LBPHFaceRecognizer_create()

riconoscimento.read('trainer/trainer.yml')

cascadePath = “haarcascade_frontalface_default.xml”

faceCascade = cv2.CascadeClassifier(cascadePath);

carattere = cv2.FONT_HERSHEY_SIMPLEX

#inizia contatore ID

id = 0

# nomi relativi agli id: esempio ==> upGrad: id=1, ecc

nomi = ['Nessuno', upGrad', Io', 'Amico', 'Y', 'X']

# Inizializza e avvia l'acquisizione video in tempo reale

cam = cv2.VideoCapture(0)

cam.set(3, 640) # imposta la larghezza del video

cam.set(4, 480) # imposta l'altezza del video

# Definisci la dimensione minima della finestra per essere riconosciuta come una faccia

minW = 0,1*cam.get(3)

minH = 0,1*cam.get(4)

mentre Vero:

ret, img =cam.read()

img = cv2.flip(img, -1) # Capovolgi verticalmente

grigio = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

facce = faceCascade.detectMultiScale(

grigio,

fattore di scala = 1,2,

minNeighbors = 5,

minSize = (int(minW), int(minH)),

)

for(x,y,w,h) in facce:

cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2)

id, fiducia = riconoscimento.predict(gray[y:y+h,x:x+w])

# Se la confidenza è inferiore a 100 ==> “0” : corrispondenza perfetta

se (confidenza < 100):

id = nomi[id]

confidenza = ” {0}%”.format(round(100 – confidenza))

altro:

id = “sconosciuto”

confidenza = ” {0}%”.format(round(100 – confidenza))

cv2.putText(

img,

str(id),

(x+5,y-5),

font,

1,

(255.255.255),

2

)

cv2.putText(

img,

str(fiducia),

(x+5,y+h-5),

font,

1,

(255.255,0),

1

)

cv2.imshow('camera',img)

k = cv2.waitKey(10) & 0xff # Premere 'ESC' per uscire dal video

se k == 27:

rottura

# Fai una pulizia

print("\n [INFO] Chiusura del programma e pulizia in corso")

cam.release()

cv2.destroyAllWindows()

Abbiamo raggiunto la fine del nostro progetto di rilevamento dei volti in Python. Ora sai come creare un modello di apprendimento automatico che rileva e riconosce i volti. Assicurati di condividere i tuoi risultati con noi!

Impara: Tutorial sul rilevamento di oggetti TensorFlow per principianti

Ulteriori informazioni sull'apprendimento automatico

Ci auguriamo che questo progetto di rilevamento dei volti ti sia piaciuto. Se vuoi renderlo più impegnativo, puoi aggiungere più facce nel tuo set di dati e addestrare il tuo modello di conseguenza. Puoi anche combinarlo con altre librerie ed estendere il progetto a qualcos'altro, come un sistema di sicurezza per il rilevamento dei volti per un programma!

Se sei interessato a saperne di più sull'apprendimento automatico, dai un'occhiata al programma Executive PG di IIIT-B e upGrad in Machine Learning e AI, progettato per i professionisti che lavorano e offre oltre 450 ore di formazione rigorosa, oltre 30 casi di studio e incarichi, IIIT -B Status di Alumni, oltre 5 progetti pratici pratici e assistenza sul lavoro con le migliori aziende.