TensorFlow is in alsidich ark om masine-learmodellen te meitsjen.
Yn dit post sille wy sjen hoe't jo in systeem foar gesichtsherkenning kinne oanmeitsje mei TensorFlow, in iepen-boarne masine-learenkader. Wy sille de essensjele prosessen oergean by it meitsjen fan in suksesfol systeem foar gesichtsherkenning, fan it sammeljen en tarieden fan gegevens oant it trainen en beoardieljen fan in model.
Jo sille ûnderfining út earste hân krije mei TensorFlow om gesichtsherkenning te meitsjen mei help fan koadefragmenten en echte foarbylden. Jo binne wolkom om te folgjen as wy trochgean.
Yntroduksje ta TensorFlow
TensorFlow is in fergese en iepen boarne bibleteek. It is in symboalyske wiskundige toolbox dy't dataflow en differinsjabele programmearring brûkt. Jo kinne omgean in ferskaat oan taken mei it, ynklusyf djip neuronale netwurk trening.
TensorFlow is krêftich en oanpasber. Likegoed is it in geweldich ark foar it ûntwikkeljen en it ynsetten fan masine-learmodellen. Jo kinne yngewikkelde modellen bouwe mei ferskate lagen en tensoroperaasjes. Ek kinne foarboude modellen yn 'e biblioteek fine-tuned wurde foar spesifike behoeften.
Fierder hat TensorFlow in enoarme en útwreidzjende brûkersmienskip. Dat, d'r is in oerfloed fan ynformaasje en help foar persoanen dy't nij binne op it platfoarm.
TensorFlow is populêr foar masine learen foar in part om't it in end-to-end workflow leveret. Dat, jo kinne maklik modellen konstruearje, traine en ynsette. It biedt ark en strategyen foar it ferbetterjen en skaalfergrutting fan modellen om oan spesifike easken te passen. It fariearret fan gegevens foarferwurking oant model ynset.
Wat is Gesichtsherkenning?
Gesichtsherkenning is in kompjûterfisy taak dy't identifisearret in persoan syn identifikaasje basearre op harren gesicht. Dizze technyk erkennt gesichtstrekken, lykas de foarm en tekstuer fan 'e eagen, noas en mûle.
En, it fergeliket se mei in databank fan bekende gesichten om in wedstriid te identifisearjen. Gesichtsherkenning hat ferskate gebrûk, ynklusyf feiligenssystemen, foto-organisaasje, en biometryske autentikaasje.
De krektens fan 'e algoritme foar gesichtsherkenning is de lêste jierren signifikant tanommen as gefolch fan trochbraken yn masine learen.
It ymportearjen fan nedige biblioteken
Foardat jo wat begjinne, moatte wy de biblioteken ymportearje dy't nedich binne foar ús model. Tensorflow (tf) wurdt ymportearre en brûkt om it model te meitsjen en te trenen. <(p>
"numpy" fiert wiskundige berekkeningen en gegevens ferwurking.
"matplotlib.pyplot" wurdt ymportearre as plt en brûkt foar data charting en fisualisaasjes.
Ta beslút, "helje lfw minsken" wurdt ymportearre út sklearn. datasets en brûkt om de gegevens foar gesichtsherkenning te laden. Dizze funksje is diel fan 'e scikit-learn toolkit. Troch dizze funksje hoegden wy gjin oare dataset te uploaden. Dit is al boud yn sckit-learn.
En, it jout jo tagong ta in breed oanbod fan datasets foar masine learen oanfraach. Yn dit senario brûke wy de fetch lfw people metoade om de dataset "Labeled Faces in the Wild" (LFW) werom te heljen. It omfettet foto's fan gesichten fan minsken en ek de labels dy't der by hearre.
Dizze biblioteken binne kritysk yn 'e ymplemintaasje en evaluaasje fan ús gesichtsherkenningsmodel.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
De gegevensset foar gesichtsherkenning foarferwurkje en laden
Yn dit diel brûke wy de funksje "fetch lfw people" om de gegevens foar gesichtsherkenning foar te ferwurkjen. Earst brûke wy lfw minsken ophelje mei de opsje "min gesichten per persoan = 60". Dit jout oan dat wy allinnich persoanen yn de dataset opnimme wolle dy't op syn minst 60 foto's hawwe. Dêrom soargje wy derfoar dat ús model genôch gegevens hat om te learen. Ek ferleget dit it gefaar fan overfitting.
De gegevens en labels fan it gesichtsobjekt wurde dan ekstrahearre en tawiisd oan de fariabelen X en y. X hol.
Wy binne no ree om ús model foar gesichtsherkenning te trainen mei foarbewurke gegevens en labels.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Splitting Training en Test Sets
Yn dizze stap spjalte wy ús dataset foar gesichtsherkenning yn twa helten mei de treintestsplitmetoade út sklearn.model seleksje. It doel fan dizze split is om de prestaasjes fan ús model nei training te beoardieljen
De trein test split funksje akseptearret as ynput gegevens X en labels y. En, it dielt se yn training- en testsets. Wy selektearje testgrutte = 0.2 yn dit foarbyld. Dit betsjut dat 20% fan 'e gegevens sille wurde brûkt as de testset en 80% as de trainingsset. Fierder brûke wy willekeurige steat = 42 om te soargjen dat de gegevens konsekwint ferdield wurde elke kear as de koade wurdt útfierd.
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)
It tarieden fan de gegevens
It doel fan it foarferwurkjen fan gegevens is om it te meitsjen foar yngong yn it model. De gegevens wurde yn dizze koade foarbewurke troch elk gegevenspunt te dielen troch 255.
Wat motivearre ús om dit te berikken? Normalisaasje is in foarferwurkingsproseduere dy't brûkt wurdt yn masine learen om te garandearjen dat alle funksjes op deselde skaal binne. Yn dit senario, dielen troch 255 skaal de gegevens nei in berik fan 0 oant 1, dat is in gewoane stap foar normalisaasje fan ôfbyldingsgegevens.
Dit fersnelt de konverginsje fan it model en kin de prestaasjes ferheegje.
X_train = X_train / 255.0
X_test = X_test / 255.0
It meitsjen fan de modus
Wy wolle it yndividu identifisearje waans gesicht op in foto ferskynt. Yn dit gefal sille wy in folslein ferbûn netwurk brûke, faak bekend as in ticht netwurk. It is in keunstmjittich neural netwurk dat waard brûkt om it model te meitsjen.
Keunstmjittige neuronale netwurken wurde modeleare nei hoe't it minsklik brein wurket en wurdt organisearre. Se besteane út ynformaasje-ferwurkjende knopen as neuroanen dy't keppele binne. Elke neuron yn in laach yn in ticht netwurk is keppele oan elke neuron yn 'e laach dêrboppe.
It model hat fjouwer lagen yn dizze koade. Om yn 'e folgjende laach te fieden, wurde de ynfiergegevens yn' e earste laach yn in iendiminsjonale array flakke. De 128 en 64 neuroanen yn 'e folgjende twa lagen binne dus folslein keppele.
De ReLU-aktivearringsfunksje is in unike aktivearringsfunksje brûkt troch dizze lagen. Dêrmei kinne wy it model krije om net-lineêre korrelaasjes te learen tusken de yn- en útgongen. De lêste laach brûkt de softmax-aktivearringsfunksje om foarsizzingen te meitsjen. En, it is in folslein ferbûn laach mei safolle neuronen as d'r potinsjele klassen binne.
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')
])
Kompilaasje fan it model
It model wurdt kompilearre mei de funksje "kompile". Wy moatte it model foar training tariede. Dat, wy sille de optimizer, ferliesfunksje en metriken definiearje dy't sille wurde brûkt om it model te beoardieljen.
Tidens training is de optimizer ferantwurdlik foar it feroarjen fan de parameters fan it model. De "adam" optimizer is in populêre technyk foar optimalisearjen fan djip learen.
Wy brûke de ferliesfunksje om de prestaasjes fan it model te beoardieljen op 'e trainingsgegevens. Om't de doeletiketten heule getallen binne dy't de klasse fan 'e ôfbylding reflektearje yn stee fan ien-hot kodearre fektors, is de ferliesfunksje "spare categorical crossentropy" geunstich.
Uteinlik definiearje wy de metriken om it model te beoardieljen, yn dit gefal, "krektens".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Model Training
Wy sille de funksje "fit" brûke om it model te trenen.
Wy sille de trainingsgegevens (X-trein) en relatearre labels (y-trein) leverje, en ek it oantal epoken (iteraasjes) ynstelle om te rinnen as 10. De trainingproseduere feroaret de modelgewichten om in ferlies te ferminderjen (it ferskil tusken foarseine en echte labels) en ferbetterje de krektens fan trainingsgegevens.
model.fit(X_train, y_train, epochs=10)
Model Evaluaasje
No moatte wy it oplaat model beoardielje op 'e testgegevens. Wy brûke it testferlies en testkrektens wurde brûkt om de prestaasjes fan it model te beoardieljen. Op de testgegevens X-test en de testetiketten y-test moatte wy "de model.evaluate-funksje" neame.
De funksje jout de testnoaiens en testferlies út. De fariabelen test ferlies en test krektens, respektivelik, befetsje dizze wearden. Uteinlik brûke wy de funksje "printsje" om de testkrektens út te fieren.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Klassen foarsizze en de foarseine klassen krije
Mei help fan it trainingsmodel en de testgegevens makket it algoritme foarsizzings. As de testgegevens trochjûn wurde oan 'e metoade "model.predict", jout it in array fan foarsizzingen út foar elke ôfbylding yn 'e testset.
De doelklassenamme foar elke ôfbylding wurdt dan ophelle út 'e list "doelnammen" mei de funksje "np.argmax" om de yndeks te identifisearjen mei de grutste foarseine kâns. Dizze yndeks wurdt dan brûkt om de foarsein klasse foar elke ôfbylding te bepalen.
Mei help fan in listbegryp wurde alle foarsizzingen yn 'e array "foarsizzingen" ûnderwurpen oan dizze metoade, wat resulteart yn 'e list "foarseine klassen".
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualisearje de foarsizzingen
Wy kinne no sjen hoe't ús model derút sjocht.
Om te evaluearjen hoe goed it model docht, sille de earste 10 foto's en har foarsizzingen wurde toand. It sil de foto's yn griisskalen plotje en sawol de eigentlike klasse fan 'e ôfbylding werjaan as de klasse foarsein troch it model mei de matplotlib.pyplot-module.
De funksje "imshow" wurdt brûkt troch de for-loop om elk fan 'e earste 10 testsetfoto's te plotten. Doelnammen[y test[i]] en foarseine klassen[i] wurde brûkt om respektivelik de werklike klasse en de foarsizze klasse fan it byld te bepalen. De titels fan elke plot wurde dan oanjûn troch dizze klassifikaasjes.
Ta beslút, it plot wurdt werjûn mei help fan de plt.show () metoade.
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()
Gearfetsje
TensorFlow biedt in folsleine en fleksibele omjouwing foar it meitsjen fan masine-learmodellen.
Troch it model te fine-tunen om oan bepaalde easken te foldwaan of troch nije ûntjouwings yn masine learen ta te foegjen, kin de krektens fan it model noch fierder wurde ferhege.
TensorFlow en gesichtsherkenning sille yn 'e takomst wierskynlik hieltyd mear wurde brûkt yn yndustry lykas feiligenssystemen, biometryske autentikaasje en sûnenssoarch. Wy sille ynkoarten fassinearjende ynnovaasjes sjen.
Leave a Reply