TensorFlow ist ein vielseitiges Tool zum Erstellen von Modellen für maschinelles Lernen.
In diesem Beitrag sehen wir uns an, wie man mit TensorFlow, einem Open-Source-Framework für maschinelles Lernen, ein Gesichtserkennungssystem erstellt. Wir werden die wesentlichen Prozesse bei der Erstellung eines erfolgreichen Gesichtserkennungssystems durchgehen, von der Erfassung und Aufbereitung von Daten bis hin zum Trainieren und Bewerten eines Modells.
Sie erhalten Erfahrungen aus erster Hand mit TensorFlow, um mithilfe von Codeschnipseln und Beispielen aus der Praxis eine Gesichtserkennung zu erstellen. Sie können uns gerne begleiten, wenn wir fortfahren.
Einführung in TensorFlow
TensorFlow ist eine kostenlose Open-Source-Bibliothek. Es ist eine symbolische mathematische Toolbox, die Datenfluss und differenzierbare Programmierung verwendet. Sie können damit eine Reihe von Aufgaben erledigen, einschließlich Deep neuronale Netzwerk Ausbildung.
TensorFlow ist leistungsstark und anpassungsfähig. Ebenso ist es ein großartiges Werkzeug für die Entwicklung und Bereitstellung von Modellen für maschinelles Lernen. Sie können komplizierte Modelle mit mehreren Schichten und Tensoroperationen erstellen. Außerdem können vorgefertigte Modelle in der Bibliothek für spezifische Anforderungen optimiert werden.
Darüber hinaus hat TensorFlow eine riesige und wachsende Benutzergemeinschaft. Es gibt also eine Fülle von Informationen und Hilfe für Personen, die neu auf der Plattform sind.
TensorFlow ist beliebt für Maschinelles Lernen zum Teil, weil es einen End-to-End-Workflow bietet. So können Sie Modelle einfach konstruieren, trainieren und bereitstellen. Es bietet Werkzeuge und Strategien zur Verbesserung und Skalierung von Modellen, um sie an spezifische Anforderungen anzupassen. Es variiert von der Datenvorverarbeitung bis zur Modellbereitstellung.
Was ist Gesichtserkennung?
Gesichtserkennung ist eine Computer Vision Aufgabe, die die Identifikation einer Person anhand ihres Gesichts identifiziert. Diese Technik erkennt Gesichtsmerkmale wie Form und Textur von Augen, Nase und Mund.
Und es vergleicht sie mit einer Datenbank bekannter Gesichter, um eine Übereinstimmung zu identifizieren. Die Gesichtserkennung hat mehrere Verwendungszwecke, darunter Sicherheitssysteme, Fotoorganisation und biometrische Authentifizierung.
Die Genauigkeit von Gesichtserkennungsalgorithmen hat in den letzten Jahren aufgrund von Durchbrüchen im maschinellen Lernen erheblich zugenommen.
Importieren erforderlicher Bibliotheken
Bevor wir anfangen, müssen wir die für unser Modell benötigten Bibliotheken importieren. Tensorflow (tf) wird importiert und verwendet, um das Modell zu erstellen und zu trainieren. <(p>
„numpy“ führt mathematische Berechnungen und Datenverarbeitung durch.
„matplotlib.pyplot“ wird als plt importiert und verwendet für Datendiagramme und Visualisierungen.
Schließlich wird „fetch lfw people“ aus sklearn importiert. Datensätze und zum Laden des Gesichtserkennungsdatensatzes verwendet. Diese Funktion ist Teil des scikit-learn-Toolkits. Dank dieser Funktion mussten wir keinen weiteren Datensatz hochladen. Dies ist bereits in sckit-learn integriert.
Und es bietet Ihnen Zugriff auf eine breite Palette von Datensätze für maschinelles Lernen Anwendungen. In diesem Szenario verwenden wir die Methode „lfw people“ zum Abrufen des Datensatzes „Labeled Faces in the Wild“ (LFW). Es umfasst Fotos von Gesichtern sowie die dazugehörigen Etiketten.
Diese Bibliotheken sind entscheidend für die Implementierung und Bewertung unseres Gesichtserkennungsmodells.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Vorverarbeitung und Laden des Gesichtserkennungsdatensatzes
In diesem Teil verwenden wir die Funktion „LFW-Personen abrufen“, um die Gesichtserkennungsdaten vorzuverarbeiten. Zuerst verwenden wir lfw people mit der Option „Min Faces per Person=60“. Dies deutet darauf hin, dass wir nur Personen in den Datensatz aufnehmen wollen, die mindestens 60 Fotos haben. Daher stellen wir sicher, dass unser Modell über ausreichende Daten zum Lernen verfügt. Außerdem verringert dies die Gefahr einer Überanpassung.
Die Daten und Beschriftungen aus dem Flächenobjekt werden dann extrahiert und den Variablen X und y zugewiesen. X hol.
Wir sind jetzt bereit, unser Gesichtserkennungsmodell mit vorverarbeiteten Daten und Labels zu trainieren.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Aufteilen von Trainings- und Testsets
In diesem Schritt teilen wir unseren Gesichtserkennungsdatensatz in zwei Hälften, indem wir die Train-Test-Split-Methode von sklearn.model selection verwenden. Das Ziel dieser Aufteilung ist es, die Leistung unseres Modells nach dem Training zu bewerten
Die Train-Test-Split-Funktion akzeptiert als Eingaben Daten X und Labels y. Und es unterteilt sie in Trainings- und Testsets. In diesem Beispiel wählen wir Testgröße = 0.2. Das bedeutet, dass 20 % der Daten als Testdatensatz und 80 % als Trainingsdatensatz verwendet werden. Darüber hinaus verwenden wir random state=42, um sicherzustellen, dass die Daten bei jeder Ausführung des Codes konsistent aufgeteilt werden.
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)
Vorbereiten der Daten
Der Zweck der Vorverarbeitung von Daten besteht darin, sie für die Eingabe in das Modell vorzubereiten. Die Daten werden in diesem Code vorverarbeitet, indem jeder Datenpunkt durch 255 dividiert wird.
Was hat uns motiviert, dies zu erreichen? Die Normalisierung ist ein Vorverarbeitungsverfahren, das beim maschinellen Lernen verwendet wird, um sicherzustellen, dass alle Merkmale im gleichen Maßstab sind. In diesem Szenario skaliert das Teilen durch 255 die Daten auf einen Bereich von 0 bis 1, was ein gewöhnlicher Bilddaten-Normalisierungsschritt ist.
Dies beschleunigt die Konvergenz des Modells und kann seine Leistung steigern.
X_train = X_train / 255.0
X_test = X_test / 255.0
Erstellen des Modus
Wir wollen die Person identifizieren, deren Gesicht auf einem Bild erscheint. In diesem Fall verwenden wir ein vollständig verbundenes Netzwerk, das oft als dichtes Netzwerk bezeichnet wird. Es ist ein künstliches neuronales Netzwerk, das verwendet wurde, um das Modell zu erstellen.
Künstliche neuronale Netze sind der Funktionsweise und Organisation des menschlichen Gehirns nachempfunden. Sie bestehen aus informationsverarbeitenden Knoten oder Neuronen, die miteinander verbunden sind. Jedes Neuron in einer Schicht in einem dichten Netzwerk ist mit jedem Neuron in der darüber liegenden Schicht verbunden.
Das Modell hat in diesem Code vier Schichten. Um in die nächste Schicht eingespeist zu werden, werden die Eingabedaten in der ersten Schicht zu einem eindimensionalen Array abgeflacht. Die 128 und 64 Neuronen in den folgenden zwei Schichten sind dementsprechend vollständig verknüpft.
Die ReLU-Aktivierungsfunktion ist eine einzigartige Aktivierungsfunktion, die von diesen Schichten verwendet wird. Damit können wir das Modell dazu bringen, nichtlineare Korrelationen zwischen den Eingaben und Ausgaben zu lernen. Die letzte Schicht verwendet die Softmax-Aktivierungsfunktion, um Vorhersagen zu treffen. Und es ist eine vollständig verbundene Schicht mit so vielen Neuronen, wie es potenzielle Klassen gibt.
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')
])
Kompilieren des Modells
Das Modell wird mit der Funktion „compile“ kompiliert. Wir müssen das Modell für das Training vorbereiten. Wir werden also den Optimierer, die Verlustfunktion und die Metriken definieren, die zur Bewertung des Modells verwendet werden.
Während des Trainings ist der Optimierer dafür verantwortlich, die Parameter des Modells zu ändern. Der „Adam“-Optimierer ist eine beliebte Deep-Learning-Optimierungstechnik.
Wir verwenden die Verlustfunktion, um die Leistung des Modells anhand der Trainingsdaten zu bewerten. Da die Zieletiketten ganze Zahlen sind, die die Klasse des Bildes widerspiegeln, und keine One-Hot-codierten Vektoren, ist die Verlustfunktion „spärliche kategoriale Kreuzentropie“ günstig.
Schließlich definieren wir die Metriken zur Bewertung des Modells, in diesem Fall „Genauigkeit“.
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Modelltraining
Wir werden die „fit“-Funktion verwenden, um das Modell zu trainieren.
Wir werden die Trainingsdaten (X-Zug) und zugehörige Bezeichnungen (y-Zug) bereitstellen und die Anzahl der auszuführenden Epochen (Iterationen) auf 10 festlegen. Das Trainingsverfahren modifiziert die Modellgewichtungen, um einen Verlust (die Differenz zwischen vorhergesagte und echte Labels) und die Genauigkeit der Trainingsdaten verbessern.
model.fit(X_train, y_train, epochs=10)
Modellbewertung
Jetzt müssen wir das trainierte Modell anhand der Testdaten bewerten. Wir verwenden den Testverlust und die Testgenauigkeit, um die Leistung des Modells zu bewerten. Bei den Testdaten X test und den Testlabels y test müssen wir „the model.evaluate function“ aufrufen.
Die Funktion gibt die Testgenauigkeit und den Testverlust aus. Die Variablen Testverlust bzw. Testgenauigkeit enthalten diese Werte. Abschließend verwenden wir die Funktion „Drucken“, um die Prüfgenauigkeit auszugeben.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Vorhersagen von Klassen und Abrufen der vorhergesagten Klassen
Unter Verwendung des Trainingsmodells und der Testdaten trifft der Algorithmus Vorhersagen. Wenn die Testdaten an die „model.predict“-Methode übergeben werden, gibt sie ein Array von Vorhersagen für jedes Bild im Testsatz aus.
Der Zielklassenname für jedes Bild wird dann mithilfe der Funktion „np.argmax“ aus der Liste „Zielnamen“ abgerufen, um den Index mit der größten vorhergesagten Wahrscheinlichkeit zu identifizieren. Dieser Index wird dann verwendet, um die vorhergesagte Klasse für jedes Bild zu bestimmen.
Unter Verwendung eines Listenverständnisses werden alle Vorhersagen im Array „Vorhersagen“ diesem Verfahren unterzogen, was zu der Liste „vorhergesagte Klassen“ führt.
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualisierung der Vorhersagen
Wir können jetzt sehen, wie unser Modell aussieht.
Um zu beurteilen, wie gut das Modell abschneidet, werden die ersten 10 Fotos und ihre Vorhersagen gezeigt. Es zeichnet die Fotos in Graustufen und zeigt sowohl die tatsächliche Klasse des Bildes als auch die vom Modell vorhergesagte Klasse mit dem Modul matplotlib.pyplot an.
Die „imshow“-Funktion wird von der for-Schleife verwendet, um jedes der ersten 10 Testset-Fotos zu plotten. Zielnamen[y test[i]] und vorhergesagte Klassen[i] werden verwendet, um die tatsächliche Klasse bzw. die vorhergesagte Klasse des Bildes zu bestimmen. Die Titel der einzelnen Plots werden dann durch diese Klassifikationen angezeigt.
Schließlich wird der Plot mit der Methode plt.show() angezeigt.
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()
Einpacken
TensorFlow bietet eine vollständige und flexible Umgebung zum Erstellen von Modellen für maschinelles Lernen.
Durch die Feinabstimmung des Modells auf bestimmte Anforderungen oder durch das Hinzufügen neuer Entwicklungen im maschinellen Lernen kann die Genauigkeit des Modells noch weiter erhöht werden.
TensorFlow und Gesichtserkennung werden in Zukunft wahrscheinlich zunehmend in Branchen wie Sicherheitssystemen, biometrischer Authentifizierung und im Gesundheitswesen eingesetzt. Faszinierende Innovationen werden wir in Kürze sehen.
Hinterlassen Sie uns einen Kommentar