TensorFlow is een veelzijdige tool om machine learning-modellen te maken.
In dit bericht bekijken we hoe je een gezichtsherkenningssysteem kunt maken met TensorFlow, een open-source machine learning-framework. We zullen de essentiële processen bespreken voor het creëren van een succesvol gezichtsherkenningssysteem, van het verzamelen en voorbereiden van gegevens tot het trainen en beoordelen van een model.
Je krijgt uit de eerste hand ervaring met TensorFlow om gezichtsherkenning te creëren met behulp van codefragmenten en praktijkvoorbeelden. U bent van harte welkom om mee te volgen terwijl we verder gaan.
Inleiding tot TensorFlow
TensorFlow is een gratis en open-sourcebibliotheek. Het is een symbolische wiskundige toolbox die dataflow en differentieerbare programmering gebruikt. Je kunt er een scala aan taken mee aan, ook diep neuraal netwerk training.
TensorFlow is krachtig en aanpasbaar. Evenzo is het een geweldig hulpmiddel voor het ontwikkelen en het implementeren van machine learning-modellen. U kunt ingewikkelde modellen bouwen met meerdere lagen en tensoroperaties. Ook kunnen vooraf gebouwde modellen in de bibliotheek worden verfijnd voor specifieke behoeften.
Bovendien heeft TensorFlow een enorme en groeiende gebruikersgemeenschap. Er is dus een overvloed aan informatie en hulp voor personen die nieuw zijn op het platform.
TensorFlow is populair voor machine learning deels omdat het een end-to-end workflow biedt. U kunt dus eenvoudig modellen bouwen, trainen en implementeren. Het biedt hulpmiddelen en strategieën voor het verbeteren en schalen van modellen om aan specifieke eisen te voldoen. Het varieert van data pre-processing tot model deployment.
Wat is gezichtsherkenning?
Gezichtsherkenning is een computer visie taak die de identificatie van een persoon identificeert op basis van hun gezicht. Deze techniek herkent gezichtskenmerken, zoals de vorm en textuur van de ogen, neus en mond.
En het vergelijkt ze met een database met bekende gezichten om een match te identificeren. Gezichtsherkenning heeft verschillende toepassingen, waaronder beveiligingssystemen, fotoorganisatie en biometrische authenticatie.
De nauwkeurigheid van algoritmen voor gezichtsherkenning is de afgelopen jaren aanzienlijk toegenomen als gevolg van doorbraken in machine learning.
Benodigde bibliotheken importeren
Voordat we iets beginnen, moeten we de bibliotheken importeren die nodig zijn voor ons model. Tensorflow (tf) wordt geïmporteerd en gebruikt om het model te maken en te trainen. <(p>
"numpy" voert wiskundige berekeningen en gegevensverwerking uit.
"matplotlib.pyplot" wordt geïmporteerd als plt en gebruikt voor gegevensgrafieken en visualisaties.
Ten slotte wordt "fetch lfw people" geïmporteerd uit sklearn. datasets en gebruikt om de gezichtsherkenningsdataset te laden. Deze functie maakt deel uit van de scikit-learn toolkit. Dankzij deze functie hoefden we niet nog een dataset te uploaden. Dit is al ingebouwd in sckit-learn.
En het geeft je toegang tot een breed scala aan datasets voor machine learning toepassingen. In dit scenario gebruiken we de methode fetch lfw people om de dataset "Labeled Faces in the Wild" (LFW) op te halen. Het bevat foto's van gezichten van mensen en de labels die daarbij horen.
Deze bibliotheken zijn van cruciaal belang bij de implementatie en evaluatie van ons gezichtsherkenningsmodel.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
De gegevensset voor gezichtsherkenning voorbewerken en laden
In dit deel gebruiken we de functie "fetch lfw people" om de gezichtsherkenningsgegevens voor te verwerken. Eerst gebruiken we fetch lfw mensen met de optie “min gezichten per persoon=60”. Dit geeft aan dat we alleen personen in de dataset willen opnemen die minimaal 60 foto's hebben. Daarom zorgen we ervoor dat ons model voldoende gegevens heeft om te leren. Dit vermindert ook het gevaar van overfitting.
De gegevens en labels van het face-object worden vervolgens geëxtraheerd en toegewezen aan de variabelen X en y. X hol.
We zijn nu klaar om ons gezichtsherkenningsmodel te trainen met behulp van voorverwerkte gegevens en labels.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Trainings- en testsets splitsen
In deze stap hebben we onze gegevensset voor gezichtsherkenning in twee helften gesplitst met behulp van de train-test-splitmethode van sklearn.model-selectie. Het doel van deze splitsing is om de prestaties van ons model na de training te beoordelen
De splitsingsfunctie van de treintest accepteert als invoer gegevens X en labels y. En het verdeelt ze in trainings- en testsets. In dit voorbeeld selecteren we testgrootte=0.2. Dit houdt in dat 20% van de data wordt gebruikt als testset en 80% als trainingsset. Bovendien gebruiken we random state=42 om ervoor te zorgen dat de gegevens consistent worden verdeeld telkens wanneer de code wordt uitgevoerd.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
De gegevens voorbereiden
Het doel van het voorbewerken van gegevens is om deze voor te bereiden voor invoer in het model. De gegevens worden in deze code voorbewerkt door elk gegevenspunt te delen door 255.
Wat motiveerde ons om dit te bereiken? Normalisatie is een voorverwerkingsprocedure die wordt gebruikt bij machine learning om te garanderen dat alle functies op dezelfde schaal zijn. In dit scenario worden de gegevens door delen door 255 geschaald naar een bereik van 0 tot 1, wat een gebruikelijke stap is voor het normaliseren van beeldgegevens.
Dit versnelt de convergentie van het model en kan de prestaties verbeteren.
X_train = X_train / 255.0
X_test = X_test / 255.0
De modus maken
We willen de persoon identificeren wiens gezicht op een foto verschijnt. In dit geval gebruiken we een volledig verbonden netwerk, ook wel een dicht netwerk genoemd. Het is een kunstmatig neuraal netwerk dat werd gebruikt om het model te maken.
Kunstmatige neurale netwerken zijn gemodelleerd naar hoe het menselijk brein werkt en is georganiseerd. Ze bestaan uit informatieverwerkende knooppunten of neuronen die met elkaar verbonden zijn. Elk neuron in een laag in een dicht netwerk is gekoppeld aan elk neuron in de laag erboven.
Het model heeft vier lagen in deze code. Om in de volgende laag te worden ingevoerd, worden de invoergegevens in de eerste laag afgevlakt tot een eendimensionale array. De 128 en 64 neuronen in de volgende twee lagen zijn dus volledig met elkaar verbonden.
De activeringsfunctie van ReLU is een unieke activeringsfunctie die door deze lagen wordt gebruikt. Daarmee kunnen we het model ertoe brengen om niet-lineaire correlaties tussen de inputs en outputs te leren. De laatste laag maakt gebruik van de softmax-activeringsfunctie om voorspellingen te doen. En het is een volledig verbonden laag met evenveel neuronen als er potentiële klassen zijn.
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(62 * 47,)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(len(target_names), activation='softmax')
])
Samenstellen van het model
Het model wordt gecompileerd met behulp van de functie "compileren". We moeten het model klaarmaken voor training. We zullen dus de optimizer, verliesfunctie en statistieken definiëren die zullen worden gebruikt om het model te beoordelen.
Tijdens de training is de optimizer verantwoordelijk voor het wijzigen van de parameters van het model. De "adam"-optimizer is een populaire optimalisatietechniek voor diep leren.
We gebruiken de verliesfunctie om de prestaties van het model op de trainingsgegevens te beoordelen. Omdat de doellabels gehele getallen zijn die de klasse van de afbeelding weerspiegelen in plaats van one-hot gecodeerde vectoren, is de verliesfunctie "sparse categorical crossentropy" gunstig.
Ten slotte definiëren we de statistieken om het model te beoordelen, in dit geval "nauwkeurigheid".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Model opleiding
We zullen de "fit" -functie gebruiken om het model te trainen.
We zullen de trainingsgegevens (X-trein) en gerelateerde labels (y-trein) verstrekken, evenals het aantal tijdperken (iteraties) instellen dat moet worden uitgevoerd als 10. De trainingsprocedure past de modelgewichten aan om een verlies te verminderen (het verschil tussen voorspelde en echte labels) en de nauwkeurigheid van trainingsgegevens verbeteren.
model.fit(X_train, y_train, epochs=10)
Modelevaluatie
Nu moeten we het getrainde model beoordelen op de testgegevens. We gebruiken het testverlies en de testnauwkeurigheid om de prestaties van het model te beoordelen. Op de testgegevens X-test en de testlabels y-test moeten we "de functie model.evaluate" aanroepen
De functie voert de testnauwkeurigheid en het testverlies uit. De variabelen testverlies respectievelijk testnauwkeurigheid bevatten deze waarden. Ten slotte gebruiken we de "print" -functie om de testnauwkeurigheid uit te voeren.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Klassen voorspellen en de voorspelde klassen krijgen
Aan de hand van het trainingsmodel en de testdata doet het algoritme voorspellingen. Wanneer de testgegevens worden doorgegeven aan de methode "model.predict", voert deze een reeks voorspellingen uit voor elke afbeelding in de testset.
De naam van de doelklasse voor elke afbeelding wordt vervolgens opgehaald uit de lijst "doelnamen" met behulp van de functie "np.argmax" om de index met de grootste voorspelde waarschijnlijkheid te identificeren. Deze index wordt vervolgens gebruikt om de voorspelde klasse voor elke afbeelding te bepalen.
Met behulp van een lijstbegrip worden alle voorspellingen in de array "voorspellingen" onderworpen aan deze methode, resulterend in de lijst "voorspelde klassen".
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
De voorspellingen visualiseren
We kunnen nu zien hoe ons model eruit ziet.
Om te beoordelen hoe goed het model het doet, worden de eerste 10 foto's en hun voorspellingen getoond. Het zal de foto's in grijstinten uitzetten en zowel de werkelijke klasse van de afbeelding weergeven als de klasse die door het model wordt voorspeld met behulp van de module matplotlib.pyplot.
De functie "imshow" wordt gebruikt door de for-lus om elk van de eerste 10 testsetfoto's te plotten. Doelnamen[y test[i]] en voorspelde klassen[i] worden gebruikt om respectievelijk de werkelijke klasse en de voorspelde klasse van de afbeelding te bepalen. De titels van elk perceel worden vervolgens aangegeven door deze classificaties.
Ten slotte wordt de plot weergegeven met behulp van de methode plt.show().
for i in range(10):
plt.imshow(X_test[i].reshape(62, 47), cmap='gray')
plt.title(f"True: {target_names[y_test[i]]}, Predicted:{predicted_classes[i]}")
plt.show()
verpakken
TensorFlow biedt een complete en flexibele omgeving voor het maken van machine learning-modellen.
Door het model te verfijnen om aan bepaalde vereisten te voldoen of door nieuwe ontwikkelingen in machine learning toe te voegen, kan de nauwkeurigheid van het model nog verder worden verhoogd.
TensorFlow en gezichtsherkenning zullen in de toekomst waarschijnlijk steeds meer worden gebruikt in sectoren zoals beveiligingssystemen, biometrische authenticatie en gezondheidszorg. We zullen binnenkort fascinerende innovaties zien.
Laat een reactie achter