TensorFlow ass e versatile Tool fir Maschinnléiere Modeller ze kreéieren.
An dësem Post wäerte mir kucken wéi een e Gesiichtserkennungssystem mat TensorFlow erstellt, en Open-Source Maschinnléiere Kader. Mir wäerten iwwer déi wesentlech Prozesser bei der Schafung vun engem erfollegräiche Gesiichtserkennungssystem iwwergoen, vun Daten sammelen an virbereeden fir e Modell ze trainéieren an ze bewäerten.
Dir kritt éischt Hand Erfarung mat TensorFlow fir Gesiichtserkennung mat Hëllef vu Code Snippets a Real-Welt Beispiller ze kreéieren. Dir sidd häerzlech häerzlech häerzlech wëllkomm matzemaachen wéi mir weidergoen.
Aféierung fir TensorFlow
TensorFlow ass eng gratis an Open Source Bibliothéik. Et ass eng symbolesch mathematesch Toolbox déi Dataflow an differenzéierbar Programméierung benotzt. Dir kënnt eng Rei vun Aufgaben mat et verschaffen, dorënner déif neural Netz Training.
TensorFlow ass mächteg an adaptéierbar. Och ass et e super Tool fir z'entwéckelen an Maschinn Léieren Modeller ofsetzen. Dir kënnt komplizéiert Modeller mat verschiddene Schichten an Tensor Operatiounen bauen. Och pre-gebaute Modeller an der Bibliothéik kënne fir spezifesch Bedierfnesser ofgestëmmt ginn.
Ausserdeem huet TensorFlow eng rieseg an erweidert Benotzergemeinschaft. Also, et gëtt eng Onmass vun Informatioun an Hëllef fir Individuen déi nei op der Plattform sinn.
TensorFlow ass populär fir Maschinn léieren deelweis well et en Enn-zu-Enn Workflow ubitt. Also, Dir kënnt einfach Modeller konstruéieren, trainéieren an ofsetzen. Et bitt Tools a Strategien fir Modeller ze verbesseren an ze skaléieren fir spezifesch Ufuerderungen ze passen. Et variéiert vun Donnéeën Virveraarbechtung bis Modell Deployment.
Wat ass Gesiichtserkennung?
Gesiichtserkennung ass eng Computer Visioun Aufgab, déi d'Identifikatioun vun enger Persoun identifizéiert baséiert op hirem Gesiicht. Dës Technik erkennt Gesiichtseigenschaften, wéi d'Form an d'Textur vun den Aen, Nues a Mond.
An, et vergläicht se mat enger Datebank vu bekannte Gesiichter fir e Match z'identifizéieren. Gesiichtserkennung huet verschidde Gebrauch, dorënner Sécherheetssystemer, Fotoorganisatioun a biometresch Authentifikatioun.
D'Genauegkeet vun der Gesiichtserkennungsalgorithmen ass an de leschte Joeren wesentlech eropgaang als Resultat vun Duerchbroch am Maschinnléieren.
Néideg Bibliothéiken importéieren
Ier Dir eppes starten, musse mir d'Bibliothéiken importéieren, déi fir eise Modell néideg sinn. Tensorflow (tf) gëtt importéiert a benotzt fir de Modell ze kreéieren an ze trainéieren. <(p>
"numpy" mécht mathematesch Berechnungen an Daten Veraarbechtung.
"matplotlib.pyplot" gëtt als plt importéiert a benotzt fir Daten Charting a Visualiséierungen.
Schlussendlech gëtt "fetch lfw people" aus sklearn importéiert. Datesets a benotzt fir d'Gesiichtserkennungsdates ze lueden. Dës Funktioun ass Deel vum scikit-learn Toolkit. Dank dëser Funktioun hu mir keng aner Datesätz eropgelueden. Dëst ass scho a sckit-learn gebaut.
An, et gëtt Iech Zougang zu enger breet Palette vun Datesets fir Maschinnléieren Uwendungen. An dësem Szenario benotze mir d'Fetch lfw people Method fir de "Labeled Faces in the Wild" (LFW) Dataset ze recuperéieren. Et besteet aus Fotoe vu Gesiichter vun de Leit wéi och d'Etiketten déi mat hinnen goen.
Dës Bibliothéike si kritesch bei der Ëmsetzung an der Evaluatioun vun eisem Gesiichtserkennungsmodell.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Virveraarbechtung a Luede vum Gesiichtserkennungsdateset
An dësem Deel benotze mir d'Funktioun "fetch lfw people" fir d'Gesiichtserkennungsdaten virzebereeden. Als éischt benotze mir lfw Leit sichen mat der Optioun "min Gesiichter pro Persoun = 60". Dëst weist datt mir nëmmen Persounen an der Datebank wëllen ophuelen, déi op d'mannst 60 Fotoen hunn. Dofir suerge mir fir datt eise Modell adäquat Daten huet fir ze léieren. Och dëst reduzéiert d'Gefor vun Iwwerfitting.
D'Donnéeën an d'Etiketten aus dem Gesiichtsobjekt ginn dann extrahéiert an un d'Variabelen X an y zougewisen. X hol.
Mir sinn elo prett eise Gesiichtserkennungsmodell mat virveraarbechtte Daten an Etiketten ze trainéieren.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Split Training an Test Sets
An dësem Schrëtt, deelen mir eis Gesiicht Unerkennung Dataset an zwou Halschent mat der Zuch Test Split Method vun sklearn.model Auswiel benotzt. D'Zil vun dëser Split ass d'Leeschtung vun eisem Modell nom Training ze bewäerten
D'Zuchtest Split Funktioun akzeptéiert als Input Daten X an Etiketten y. An, et trennt se an Trainings- an Testsets. Mir wielen Testgréisst = 0.2 an dësem Beispill. Dëst implizéiert datt 20% vun den Donnéeën als Testset benotzt ginn an 80% als Trainingsset. Ausserdeem benotze mir zoufälleg Staat = 42 fir sécherzestellen datt d'Donnéeën konsequent opgedeelt ginn all Kéier wann de Code duerchgefouert gëtt.
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)
Virbereedung vun Daten
Den Zweck vun der Virveraarbechtung vun Donnéeën ass et ze preparéieren fir an de Modell anzegoen. D'Date ginn an dësem Code virveraarbecht andeems Dir all Datepunkt mat 255 deelt.
Wat huet eis motivéiert dëst z'erreechen? Normaliséierung ass eng Virveraarbechtungsprozedur déi am Maschinnléiere benotzt gëtt fir ze garantéieren datt all Feature op der selwechter Skala sinn. An dësem Szenario, deelt duerch 255 skaléiert d'Donnéeën op eng Rei vun 0 bis 1, wat e gewéinleche Bilddatennormaliséierungsschrëtt ass.
Dëst beschleunegt d'Konvergenz vum Modell a kann seng Leeschtung erhéijen.
X_train = X_train / 255.0
X_test = X_test / 255.0
Erstellt de Modus
Mir wëllen den Individuum identifizéieren deem säi Gesiicht an engem Bild erschéngt. An dësem Fall wäerte mir e komplett verbonne Netzwierk benotzen, dacks als dichten Netzwierk bekannt. Et ass e kënschtlecht neuralt Netzwierk dat benotzt gouf fir de Modell ze kreéieren.
Kënschtlech neural Netzwierker ginn modelléiert no wéi de mënschleche Gehir funktionnéiert an organiséiert ass. Si besteet aus Informatiounsveraarbechtungsnoden oder Neuronen déi verlinkt sinn. All Neuron an enger Schicht an engem dichten Netzwierk ass mat all Neuron an der Schicht driwwer verbonnen.
De Modell huet véier Schichten an dësem Code. Fir an déi nächst Schicht gefüttert ze ginn, ginn d'Inputdaten an der éischter Schicht an eng eendimensional Array verflaacht. Déi 128 a 64 Neuronen an de folgenden zwou Schichten, deementspriechend, si komplett verbonnen.
D'ReLU Aktivéierungsfunktioun ass eng eenzegaarteg Aktivéierungsfunktioun déi vun dëse Schichten benotzt gëtt. Mat deem kënne mir de Modell kréien fir net-linear Korrelatiounen tëscht den Inputen an Ausgänge ze léieren. Déi lescht Layer benotzt d'Softmax Aktivéierungsfunktioun fir Prognosen ze maachen. An, et ass eng voll verbonne Schicht mat sou vill Neuronen wéi et potenziell Klassen sinn.
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')
])
Zesummesetzung vum Model
De Modell gëtt mat der "kompiléieren" Funktioun kompiléiert. Mir mussen de Modell fir Training virbereeden. Also, mir definéieren den Optimizer, Verloschtfunktioun a Metriken déi benotzt gi fir de Modell ze bewäerten.
Wärend dem Training ass den Optimizer zoustänneg fir d'Parameter vum Modell z'änneren. Den "Adam" Optimizer ass eng populär Deep-Learning Optimiséierungstechnik.
Mir benotzen d'Verloschtfunktioun fir d'Performance vum Modell op den Trainingsdaten ze bewäerten. Well d'Ziletikette ganz Zuelen sinn, déi d'Bildklass reflektéieren anstatt een-waarm kodéierte Vektoren, ass d'"spare categorical crossentropy" Verloschtfunktioun favorabel.
Endlech definéiere mir d'Metriken fir de Modell ze bewäerten, an dësem Fall "Genauegkeet".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Model Training
Mir benotzen d'Funktioun "Fit" fir de Modell ze trainéieren.
Mir wäerten d'Trainingsdaten (X-Zuch) a verwandte Etiketten (y Zuch) ubidden, souwéi d'Zuel vun den Epochen (Iteratiounen) op 10 setzen. virausgesot an real Etiketten) a verbesseren d'Genauegkeet vun Trainingsdaten.
model.fit(X_train, y_train, epochs=10)
Modell Evaluatioun
Elo musse mir den trainéierte Modell op den Testdaten bewäerten. Mir benotzen den Testverloscht an d'Testgenauegkeet gi benotzt fir d'Leeschtung vum Modell ze bewäerten. Op den Testdaten X Test an den Testetiketten y Test, musse mir "de model.evaluate function" nennen.
D'Funktioun gëtt d'Testgenauegkeet an den Testverloscht eraus. D'Variabelen Testverloscht an Testgenauegkeet, respektiv, enthalen dës Wäerter. Schlussendlech benotze mir d'Funktioun "Drécken" fir d'Testgenauegkeet auszeginn.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Klassen viraussoen an déi virausgesot Klassen kréien
Mat Hëllef vum Trainingsmodell an den Testdaten mécht den Algorithmus Prognosen. Wann d'Testdaten un d'Methode "model.predict" weidergeleet ginn, gëtt et eng ganz Rëtsch Prognosen fir all Bild am Testset eraus.
Den Numm vun der Zilklass fir all Bild gëtt dann aus der "Zielnimm" Lëscht mat der "np.argmax" Funktioun zréckgezunn fir den Index mat der gréisster virausgesoter Wahrscheinlechkeet z'identifizéieren. Dësen Index gëtt dann benotzt fir déi virausgesot Klass fir all Bild ze bestëmmen.
Mat engem Lëschtverständnis ginn all d'Prognosen an der "Prognosen" Array dës Method ënnerworf, wat zu der "virausgesot Klassen" Lëscht resultéiert.
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualiséieren d'Prognosen
Mir kënnen elo gesinn wéi eise Modell ausgesäit.
Fir ze evaluéieren wéi gutt de Modell et geet, ginn déi éischt 10 Fotoen an hir Prognosen gewisen. Et wäert d'Fotoen a Grauskala plotten a béid déi aktuell Klass vum Bild weisen an d'Klass virausgesot vum Modell mam matplotlib.pyplot Modul.
D'"imshow" Funktioun gëtt vun der for Loop benotzt fir jiddereng vun den éischten 10 Testsetfotoen ze plotten. Zilnimm[y Test[i]] a virausgesot Klassen[i] gi benotzt fir déi aktuell Klass an déi virausgesot Klass vum Bild ze bestëmmen, respektiv. D'Titele vun all Komplott ginn dann vun dëse Klassifikatiounen uginn.
Endlech gëtt de Komplott mat der plt.show () Method ugewisen.
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()
Apaken
TensorFlow bitt e komplett a flexibel Ëmfeld fir Maschinnléiermodeller ze kreéieren.
Andeems Dir de Modell feinstemmt fir speziell Ufuerderungen z'erhalen oder duerch nei Entwécklungen am Maschinnléieren derbäi ze ginn, kann d'Genauegkeet vum Modell nach méi erhéicht ginn.
TensorFlow a Gesiichtserkennung wäerte méiglecherweis ëmmer méi an Industrien wéi Sécherheetssystemer, biometresch Authentifikatioun, a Gesondheetsariichtung an Zukunft benotzt ginn. Mir wäerte séier faszinéierend Innovatiounen gesinn.
Hannerlooss eng Äntwert