Gezichtsherkenning en -identificatie in computerzicht

Snelle ontwikkeling in machinaal leren en AI-technologieën hebben aanzienlijke vooruitgang geboekt in computer vision voor objectdetectie en -herkenning. Toch is het creëren van een systeem dat humor en vermaak in mensen kan herkennen nog steeds een uitdagend probleem voor programmeurs, aangezien komedie en entertainment subjectief zijn en gebaseerd zijn op persoonlijke voorkeuren en culturele context. Daarom is het lastig om een systeem te creëren dat precies kan bepalen wat individuen vermaken of leuk vinden.

Toch heeft computer vision op het gebied van gezichtsherkenning en identificatie aanzienlijke vooruitgang geboekt, en wordt het breed ingezet in verschillende toepassingen zoals beveiliging, bewaking en biometrie. Gezichtsherkennings technologie identificeert voornamelijk individuen door het analyseren en vergelijken van hun gezichtskenmerken met een database van bekende gezichten. Gezichtsidentificatie betreft het matchen van een persoonlijk gezicht met hun identiteit. Het maakt gebruik van algoritmes om gezichtskenmerken te extraheren zoals de afstand tussen de ogen, neuscurven en de hoek van de kaaklijn om een uniek gezichtssignaal te genereren.

Technieken voor Gezichtsherkenning en -identificatie

Er zijn verschillende methoden voor het herkennen en identificeren van gezichten, maar deze tutorial zal zich richten op drie technieken en hun voordelen en nadelen uiteenzetten.

1. Template-Based Approach

Ten eerste vergelijkt de sjabloon-gebaseerde aanpak de gezichts kenmerken van een doel gezicht met die in een sjabloon of referentie afbeelding. Het sjabloon beeld bestaat uit verschillende gezichts kenmerken, zoals de positie van de ogen, neus, mond en de afstanden ertussen. De techniek vergelijkt vervolgens het doel gezicht met het sjabloon beeld om te bepalen of er een match is. Eigenfaces is een van de meest voorkomende sjabloon-gebaseerde methoden die hoofdcomponent analyse (PCA) gebruikt om de dimensionaliteit van gezichts afbeeldingen te verminderen en de meest relevante kenmerken te extraheren.

Voordelen

• Ze zijn zeer nauwkeurig met hoogwaardige sjablonen
• Handhabeert variaties in belichting en gezichtsuitdrukkingen

Nadelen

• Vereist hoogwaardige sjablonen voor nauwkeurige resultaten
• Kan computationeel duur zijn

2. Kenmerk-gebaseerde aanpak

Ten tweede extraheert de kenmerk-gebaseerde techniek kenmerken uit het gezicht, zoals de vorm van de ogen, de afstand tussen de wenkbrauwen en de kromming van de lippen. De aanpak vergelijkt deze kenmerken vervolgens met die in een database van bekende gezichten om het doel gezicht te identificeren. Voorbeelden van typische kenmerk-gebaseerde technieken zijn Local Binary Pattern (LBP) en Scale-Invariant Feature Transform (SIFT).

Voordelen

• Relatief snel en efficiënt
• Werkt met lage-resolutie afbeeldingen

Nadelen

• Kan niet goed werken met wisselende belichtingsomstandigheden
• Kan niet robuust zijn voor veranderingen in gezichtsuitdrukkingen of houdingen

3. Deep Learning-Based Approach

Tot slot gebruikt een deep learning-gebaseerde aanpak diepe neurale netwerken om functies rechtstreeks uit gezichtsbeelden te leren. De netwerken worden getraind op grote datasets van gezichtsbeelden om patronen en relevante kenmerken voor gezichtsherkenning te identificeren. Voorbeelden van typische deep learning-gebaseerde methoden zijn Convolutional Neural Networks (CNN) en Siamese Networks.

Voordelen

• Bereikt hoge nauwkeurigheid met grote datasets
• Handelt variaties in gezichtsuitdrukkingen en houdingen

Nadelen

• Vereist een grote hoeveelheid trainingsgegevens
• Computationeel kostbaar

OPMERKING: Er zijn verschillende technieken voor gezichtsherkenning en identificatie.

Gezichtsherkenning en -identificatie met Python en OpenCV

Met de beschikbaarheid van krachtige bibliotheken zoals OpenCV en de vooruitgang in machine learning-algoritmen, is het tegenwoordig gemakkelijker dan ooit om gezichtsherkenning en -identificatiesystemen te ontwikkelen met Python. OpenCV biedt een rijke verzameling functies en hulpmiddelen voor beeldverwerking, met name handig bij gezichtsherkenningstaken zoals gezichtsdetectie, kenmerkextractie en matching. Het heeft ook voorgebouwde modellen zoals de Haar Cascades-classificator voor gezichtsdetectie en VGG of ResNet om de gedetecteerde gezichten te labelen.

OpenCV biedt verschillende modellen voor gezichtslabeling, zoals Eigenfaces, Fisherfaces en Local Binary Patterns Histograms (LBPH). We trainen deze modellen om specifieke individuen te identificeren door ze beelden van de individuen te laten zien die we willen herkennen. Eigenfaces gebruikt Principal Component Analysis (PCA) om een gezichtsbeeld te construeren uit kleinere delen, terwijl Fisherfaces Lineaire Discriminant Analyse (LDA) gebruikt om gezichten van elkaar te onderscheiden. LBPH vergelijkt de textuur van gezichten met bekende gezichten.

Gezichtsidentificatie

Afhankelijkheden importeren

Importeer de noodzakelijke bibliotheken.

import numpy as np
import cv2
import matplotlib.pyplot as plt
from IPython.display import Image

from google.colab import drive
drive.mount('/content/drive')

Voorbereidde modellen en afbeelding laden

OpenCV biedt een set voorbereide `Haar Cascade classifiers` voor het detecteren van verschillende objecten, inclusief gezichten. `cv2.CascadeClassifier` is een klasse die de Haar Cascade classifier vertegenwoordigt. De cv2.data.haarcascades is een pad naar de map die de voorbereide modellen bevat. `haarcascade_frontalface_default.xml` is het bestand dat het voorbereide gezichtsdetectiemodel bevat. Het model is beschikbaar voor gratis download op GitHub.

# Laad het voorbereide gezichtsdetectiemodel
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

Laad de invoerafbeelding `image1.jpg` kan een afbeelding van uw keuze zijn met behulp van OpenCV’s `imread()` functie. Het converteert vervolgens de afbeelding naar grijswaarde met behulp van OpenCV’s `cvtColor()` functie. De grijswaarde-afbeelding is vereist voor het gezichtsdetectiealgoritme.

# Laad de afbeelding en converteer deze naar grijswaarden
img = cv2.imread('/content/drive/MyDrive/Face Detection/image1.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# toon de afbeelding 
plt.imshow(gray)

De onderstaande regel detecteert gezichten in de grijswaarde afbeelding met behulp van de detectMultiScale() methode van de CascadeClassifier klasse. De detectMultiScale() methode neemt de volgende argumenten:

`gray`: de grijswaarde afbeelding

`scaleFactor`: is een parameter die aangeeft hoeveel de afbeeldingsgrootte bij elke afbeeldingsschaal wordt geminimaliseerd. Een waarde van 1,3 betekent dat de afbeelding met 30% wordt verkleind bij elke schaal.

`minNeighbors`: is een parameter die aangeeft hoeveel buren elke kandidaatrechthoek moet hebben om te behouden, hoger resultaat leidt tot minder detecties maar met hogere betrouwbaarheid.

`De detectMultiScale()` methode retourneert een lijst van rechthoeken waar gezichten zijn gedetecteerd. Elke rechthoek vertegenwoordigt een tuple van vier integers `(x,y,w,h)` die de bovenste-linkerhoek coordinaten `(x,y)` van de rechthoek en zijn breedte `w` en hoogte `h` vertegenwoordigen.

# Detecteer gezichten in de grijswaarde afbeelding
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

Teken Rechthoek op Gezichtsgebied

Laten we een lus maken die rechthoeken rond de gedetecteerde gezichten in de oorspronkelijke afbeelding tekent. De cv2.rectangle() functie neemt de volgende argumenten:

`img`: de oorspronkelijke afbeelding.    

`(x,y)`: de bovenste-linkerhoek coordinaten van de rechthoek.    

`(x+w,y+h)`: de onderste-rechterhoek coordinaten van de rechthoek.    

`(255,0,0)`: vertegenwoordigt de binair kleur van de getekende rechthoek in RGB formaat. (255,0,0) vertegenwoordigt blauw.

`5`: de dikte van de rechthoek grens in pixels.

# Teken rechthoeken rond de gedetecteerde gezichten
for (x,y,w,h) in faces:

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

#Toon de afbeelding na het bouwen van de rechthoek.


# Toon de afbeelding met de gedetecteerde gezichten

plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))

plt.show()

# Sla de gedetecteerde afbeelding op met naam
cv2.imwrite('detected_image.jpg', img)

#Bevestig of de opgeslagen afbeelding bestaat.
detected_image=cv2.imread("detected_image.jpg", 1)
gray_channels_reversed = detected_image[:, :, ::-1]
plt.imshow(gray_channels_reversed)

Gezichtsherkenning

We zullen geen uitleg geven zoals hierboven maar gebruiken de hierboven opgeslagen gedetecteerde afbeelding om te bevestigen of het model werkt voor identificatie door verschillende afbeeldingen te geven voor detectie.

Importeer Afhankelijkheden

import numpy as np
import cv2
import matplotlib.pyplot as plt
import dlib
from imutils import face_utils
from scipy.spatial.distance import cosine
from sklearn.metrics.pairwise import cosine_similarity

Laad Gezichtsdetectie Model en Gezichtslandmerken Detector

De functie `dlib.get_frontal_face_detector()` retourneert een voorgewaardeerd gezichtsdetectiemodel dat in staat is om menselijke gezichten in afbeeldingen te detecteren. Voor meer informatie, check dlib.net functies. Download ook de landmerken detector.

# Laad het gezichtsdetectiemodel en de gezichtslandmerken detector
face_detector = dlib.get_frontal_face_detector()
landmark_detector = dlib.shape_predictor('/content/drive/MyDrive/Face Detection/shape_predictor_68_face_landmarks_GTX.dat')

# Laad de gedetecteerde afbeelding van 

img1 = cv2.imread('/content/drive/MyDrive/Face Detection/detected_image.jpg')
gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)


# Detecteer het gezicht en gezichtslandmerken van de afbeelding
rects1 = face_detector(gray1, 1)
landmarks1 = landmark_detector(gray1, rects1[0])
landmarks1 = face_utils.shape_to_np(landmarks1)

# Laad een andere afbeelding om te vergelijken met de eerder geladen afbeelding
img2 = cv2.imread('/content/drive/MyDrive/Face Detection/001_d3323f3c.jpg')
gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)

### Instellen van modelparameters

# Detecteer het gezicht en gezichtslandmarken van de tweede afbeelding

rects2 = face_detector(gray2, 1)

landmarks2 = landmark_detector(gray2, rects2[0])

landmarks2 = face_utils.shape_to_np(landmarks2)

# Extraheer de kenmerken van de twee afbeeldingen door de Euclidische afstanden tussen gezichtslandmarken te berekenen

features1 = np.zeros(68)

features2 = np.zeros(68)

for i in range(68):

    features1[i] = np.linalg.norm(landmarks1[i] - landmarks1[0])

    features2[i] = np.linalg.norm(landmarks2[i] - landmarks2[0])

#### Trainen op gelijkenissen

# Bereken de cosinus gelijkenis tussen de twee kenmerkvectoren

score = cosine(features1, features2)

# Controleer of de score onder een bepaalde drempel (bijv. 0.5) ligt om te bepalen of de twee gezichten overeenkomen

if score < 0.5:

    print("The model did not recognize Joseph in one or both of the images..")

else:

    print("The model recognized Joseph in both images.")

Conclusie

In deze tutorial heb je geleerd over gezichtsherkenning en identificatie met behulp van Python OpenCV, hoe het werkt, zijn toepassingen en hoe het geïmplementeerd kan worden. De code voor dit project is te vinden op de GitHub Repo.