TensorFlow er et alsidigt værktøj til at skabe maskinlæringsmodeller.
I dette indlæg vil vi se på, hvordan man opretter et ansigtsgenkendelsessystem med TensorFlow, en open source-ramme for maskinlæring. Vi vil gennemgå de væsentlige processer i at skabe et succesfuldt ansigtsgenkendelsessystem, fra indsamling og forberedelse af data til træning og vurdering af en model.
Du får førstehåndserfaring med TensorFlow for at skabe ansigtsgenkendelse ved hjælp af kodestykker og eksempler fra den virkelige verden. Du er velkommen til at følge med, når vi går videre.
Introduktion til TensorFlow
TensorFlow er et gratis og open source-bibliotek. Det er en symbolsk matematisk værktøjskasse, der bruger dataflow og differentierbar programmering. Du kan håndtere en række opgaver med det, herunder dyb neurale netværk uddannelse.
TensorFlow er kraftfuld og tilpasningsdygtig. Ligeledes er det et fantastisk værktøj til at udvikle og implementering af maskinlæringsmodeller. Du kan bygge komplicerede modeller med flere lag og tensoroperationer. Desuden kan præbyggede modeller i biblioteket finjusteres til specifikke behov.
Desuden har TensorFlow et enormt og ekspanderende brugerfællesskab. Så der er et væld af information og hjælp til personer, der er nye på platformen.
TensorFlow er populær for machine learning dels fordi det giver en ende-til-ende arbejdsgang. Så du kan nemt konstruere, træne og implementere modeller. Det giver værktøjer og strategier til at forbedre og skalere modeller, så de passer til specifikke krav. Det varierer fra dataforbehandling til modelimplementering.
Hvad er ansigtsgenkendelse?
Ansigtsgenkendelse er en computersyn opgave, der identificerer en persons identifikation ud fra deres ansigt. Denne teknik genkender ansigtstræk, såsom form og tekstur af øjne, næse og mund.
Og den sammenligner dem med en database med kendte ansigter for at identificere et match. Ansigtsgenkendelse har flere anvendelser, herunder sikkerhedssystemer, fotoorganisering og biometrisk autentificering.
Ansigtsgenkendelsesalgoritmers nøjagtighed er steget betydeligt i de seneste år som et resultat af gennembrud inden for maskinlæring.
Import af nødvendige biblioteker
Før vi starter noget, skal vi importere de nødvendige biblioteker til vores model. Tensorflow (tf) importeres og bruges til at skabe og træne modellen. <(p>
"numpy" udfører matematiske beregninger og databehandling.
"matplotlib.pyplot" importeres som plt og bruges til datakortlægning og visualiseringer.
Endelig importeres "fetch lfw people" fra sklearn. datasæt og bruges til at indlæse ansigtsgenkendelsesdatasættet. Denne funktion er en del af scikit-learn værktøjssættet. Takket være denne funktion behøvede vi ikke at uploade endnu et datasæt. Dette er allerede indbygget i sckit-learn.
Og det giver dig adgang til en bred vifte af datasæt til maskinlæring applikationer. I dette scenarie bruger vi metoden hent lfw people til at hente datasættet "Mærkede ansigter i naturen" (LFW). Det omfatter fotos af folks ansigter samt de etiketter, der følger med dem.
Disse biblioteker er kritiske i implementeringen og evalueringen af vores ansigtsgenkendelsesmodel.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Forbehandling og indlæsning af ansigtsgenkendelsesdatasættet
I denne del bruger vi funktionen "hent lfw people" til at forbehandle ansigtsgenkendelsesdataene. Først bruger vi hente lfw-personer med muligheden "min. ansigter pr. person=60". Dette indikerer, at vi kun ønsker at inkludere personer i datasættet, som har mindst 60 billeder. Derfor sikrer vi, at vores model har tilstrækkelige data at lære. Dette mindsker også risikoen for overpasning.
Dataene og etiketterne fra ansigtsobjektet udtrækkes derefter og tildeles variablerne X og y. X hol.
Vi er nu klar til at træne vores ansigtsgenkendelsesmodel ved hjælp af forbehandlede data og etiketter.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Opdeling af trænings- og testsæt
I dette trin opdeler vi vores ansigtsgenkendelsesdatasæt i to halvdele ved hjælp af togtestopdelingsmetoden fra sklearn.model selection. Målet med denne opdeling er at vurdere vores models præstation efter træning
Togtestopdelingsfunktionen accepterer som input data X og etiketter y. Og det opdeler dem i trænings- og testsæt. Vi vælger teststørrelse=0.2 i dette eksempel. Dette indebærer, at 20 % af dataene vil blive brugt som testsæt og 80 % som træningssæt. Ydermere bruger vi random state=42 for at sikre, at dataene er opdelt konsistent, hver gang koden udføres.
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)
Forberedelse af data
Formålet med at forbehandle data er at forberede dem til indtastning i modellen. Dataene er forbehandlet i denne kode ved at dividere hvert datapunkt med 255.
Hvad motiverede os til at opnå dette? Normalisering er en forbehandlingsprocedure, der bruges i maskinlæring for at garantere, at alle funktioner er i samme skala. I dette scenarie skaleres dataene til et område på 255 til 0 ved at dividere med 1, hvilket er et normalt billeddatanormaliseringstrin.
Dette fremskynder modellens konvergens og kan øge dens ydeevne.
X_train = X_train / 255.0
X_test = X_test / 255.0
Oprettelse af tilstanden
Vi ønsker at identificere den person, hvis ansigt vises på et billede. I dette tilfælde vil vi bruge et fuldt tilsluttet netværk, ofte kendt som et tæt netværk. Det er et kunstigt neuralt netværk, der blev brugt til at skabe modellen.
Kunstige neurale netværk er modelleret efter, hvordan den menneskelige hjerne fungerer og er organiseret. De består af informationsbehandlingsknuder eller neuroner, der er forbundet. Hver neuron i et lag i et tæt netværk er forbundet med hver neuron i laget over det.
Modellen har fire lag i denne kode. For at blive ført ind i det næste lag, bliver inputdataene fladtrykt i det første lag til et endimensionelt array. De 128 og 64 neuroner i de følgende to lag er følgelig fuldstændigt forbundet.
ReLU-aktiveringsfunktionen er en unik aktiveringsfunktion, der bruges af disse lag. Med det kan vi få modellen til at lære ikke-lineære sammenhænge mellem input og output. Det sidste lag anvender softmax-aktiveringsfunktionen til at lave forudsigelser. Og det er et fuldt forbundet lag med lige så mange neuroner, som der er potentielle klasser.
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')
])
Kompilering af modellen
Modellen er kompileret ved hjælp af "compile"-funktionen. Vi skal forberede modellen til træning. Så vi vil definere optimeringsværktøjet, tabsfunktionen og målinger, der vil blive brugt til at vurdere modellen.
Under træning er det optimizeren, der står for at ændre modellens parametre. "Adam"-optimeringsværktøjet er en populær deep-learning-optimeringsteknik.
Vi bruger tabsfunktionen til at vurdere modellens præstation på træningsdataene. Fordi måletiketterne er heltal, der afspejler billedets klasse snarere end one-hot-kodede vektorer, er tabsfunktionen "spare categorical crossentropy" gunstig.
Til sidst definerer vi metrikken for at vurdere modellen, i dette tilfælde "nøjagtighed".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Model træning
Vi vil bruge "fit"-funktionen til at træne modellen.
Vi vil levere træningsdata (X-tog) og relaterede etiketter (y-tog), samt indstille antallet af epoker (iterationer) til at køre som 10. Træningsproceduren ændrer modelvægtene for at reducere et tab (forskellen mellem forudsagte og rigtige mærker) og forbedre nøjagtigheden af træningsdata.
model.fit(X_train, y_train, epochs=10)
Modelvurdering
Nu skal vi vurdere den trænede model på testdataene. Vi bruger testtabet og testnøjagtigheden bruges til at vurdere modellens ydeevne. På testdata X-testen og testetiketterne y-test skal vi kalde "model.evaluate-funktionen"
Funktionen udsender testnøjagtigheden og testtabet. Variablerne testtab og testnøjagtighed indeholder henholdsvis disse værdier. Til sidst bruger vi "print"-funktionen til at udskrive testnøjagtigheden.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Forudsigelse af klasser og få de forudsagte klasser
Ved hjælp af træningsmodellen og testdataene laver algoritmen forudsigelser. Når testdataene overføres til "model.predict"-metoden, udsender den en række forudsigelser for hvert billede i testsættet.
Målklassenavnet for hvert billede hentes derefter fra "målnavne"-listen ved hjælp af "np.argmax"-funktionen for at identificere indekset med den største forudsagte sandsynlighed. Dette indeks bruges derefter til at bestemme den forudsagte klasse for hvert billede.
Ved at bruge en listeforståelse udsættes alle forudsigelserne i "forudsigelser"-arrayet for denne metode, hvilket resulterer i listen "forudsagte klasser".
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualisering af forudsigelserne
Vi kan nu se, hvordan vores model ser ud.
For at vurdere, hvor godt modellen klarer sig, vil de første 10 billeder og deres forudsigelser blive vist. Den vil plotte billederne i gråtoner og vise både den faktiske klasse af billedet og klassen forudsagt af modellen ved hjælp af matplotlib.pyplot-modulet.
"imshow"-funktionen bruges af for-løkken til at plotte hvert af de første 10 testsætbilleder. Målnavne[y test[i]] og forudsagte klasser[i] bruges til at bestemme henholdsvis billedets faktiske klasse og forudsagte klasse. Titlerne på hvert plot er derefter angivet ved disse klassifikationer.
Til sidst vises plottet ved hjælp af plt.show() metoden.
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()
Wrap Up
TensorFlow tilbyder et komplet og fleksibelt miljø til at skabe maskinlæringsmodeller.
Ved at finjustere modellen til at opfylde særlige krav eller ved at tilføje nye udviklinger inden for maskinlæring, kan modellens nøjagtighed øges endnu mere.
TensorFlow og ansigtsgenkendelse vil sandsynligvis blive brugt i stigende grad i industrier som sikkerhedssystemer, biometrisk autentificering og sundhedspleje i fremtiden. Vi vil snart se fascinerende innovationer.
Giv en kommentar