TensorFlow er et allsidig verktøy for å lage maskinlæringsmodeller.
I dette innlegget skal vi se på hvordan du lager et ansiktsgjenkjenningssystem med TensorFlow, et maskinlæringsrammeverk med åpen kildekode. Vi vil gå gjennom de essensielle prosessene for å skape et vellykket ansiktsgjenkjenningssystem, fra innsamling og forberedelse av data til opplæring og vurdering av en modell.
Du vil få førstehåndserfaring med TensorFlow for å skape ansiktsgjenkjenning ved hjelp av kodebiter og eksempler fra den virkelige verden. Du er velkommen til å følge med når vi går videre.
Introduksjon til TensorFlow
TensorFlow er et gratis bibliotek med åpen kildekode. Det er en symbolsk matematisk verktøykasse som bruker dataflyt og differensierbar programmering. Du kan håndtere en rekke oppgaver med den, inkludert dype nevrale nettverket trening.
TensorFlow er kraftig og tilpasningsdyktig. Likeledes er det et flott verktøy for å utvikle og implementere maskinlæringsmodeller. Du kan bygge kompliserte modeller med flere lag og tensoroperasjoner. Dessuten kan forhåndsbygde modeller i biblioteket finjusteres for spesifikke behov.
Videre har TensorFlow et enormt og ekspanderende brukerfellesskap. Så det er en mengde informasjon og hjelp for enkeltpersoner som er nye på plattformen.
TensorFlow er populært for maskinlæring delvis fordi det gir en ende-til-ende arbeidsflyt. Så du kan enkelt konstruere, trene og distribuere modeller. Den gir verktøy og strategier for å forbedre og skalere modeller for å passe spesifikke krav. Det varierer fra dataforbehandling til modellimplementering.
Hva er ansiktsgjenkjenning?
Ansiktsgjenkjenning er en datasyn oppgave som identifiserer en persons identifikasjon basert på ansiktet deres. Denne teknikken gjenkjenner ansiktstrekk, som formen og teksturen til øyne, nese og munn.
Og den sammenligner dem med en database med kjente ansikter for å identifisere en match. Ansiktsgjenkjenning har flere bruksområder, inkludert sikkerhetssystemer, fotoorganisering og biometrisk autentisering.
Ansiktsgjenkjenningsalgoritmers nøyaktighet har økt betydelig de siste årene som et resultat av gjennombrudd innen maskinlæring.
Importerer nødvendige biblioteker
Før vi starter noe, må vi importere bibliotekene som trengs for modellen vår. Tensorflow (tf) importeres og brukes til å lage og trene modellen. <(p>
"numpy" utfører matematiske beregninger og databehandling.
"matplotlib.pyplot" importeres som plt og brukes til datakartlegging og visualiseringer.
Til slutt importeres «fetch lfw people» fra sklearn. datasett og brukes til å laste inn ansiktsgjenkjenningsdatasettet. Denne funksjonen er en del av scikit-learn-verktøysettet. Takket være denne funksjonen trengte vi ikke å laste opp et annet datasett. Dette er allerede bygget i sckit-learn.
Og det gir deg tilgang til et bredt spekter av datasett for maskinlæring applikasjoner. I dette scenariet bruker vi hent lfw people-metoden for å hente «Labeled Faces in the Wild» (LFW) datasettet. Den består av bilder av folks ansikter samt etikettene som følger med dem.
Disse bibliotekene er kritiske i implementeringen og evalueringen av vår ansiktsgjenkjenningsmodell.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Forbehandling og lasting av ansiktsgjenkjenningsdatasettet
I denne delen bruker vi funksjonen "hent lfw people" for å forhåndsbehandle ansiktsgjenkjenningsdataene. Først bruker vi hent lfw-personer med alternativet "min ansikter per person=60". Dette indikerer at vi kun ønsker å inkludere personer i datasettet som har minst 60 bilder. Derfor sikrer vi at modellen vår har tilstrekkelige data å lære. Dette reduserer også faren for overmontering.
Dataene og etikettene fra ansiktsobjektet trekkes deretter ut og tilordnes variablene X og y. X hol.
Vi er nå klare til å trene vår ansiktsgjenkjenningsmodell ved å bruke forhåndsbehandlede data og etiketter.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Splitting av trenings- og testsett
I dette trinnet deler vi vårt ansiktsgjenkjenningsdatasett i to halvdeler ved å bruke togtestsplittmetoden fra sklearn.model selection. Målet med denne delingen er å vurdere modellens ytelse etter trening
Togtestdelingsfunksjonen aksepterer som inngangsdata X og etiketter y. Og den deler dem inn i trenings- og testsett. Vi velger teststørrelse=0.2 i dette eksemplet. Dette innebærer at 20 % av dataene vil bli brukt som testsett og 80 % som treningssett. Videre bruker vi random state=42 for å sikre at dataene deles konsistent hver gang koden utfø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)
Forbereder dataene
Formålet med forbehandling av data er å forberede dem for innføring i modellen. Dataene er forhåndsbehandlet i denne koden ved å dele hvert datapunkt med 255.
Hva motiverte oss til å oppnå dette? Normalisering er en forbehandlingsprosedyre som brukes i maskinlæring for å garantere at alle funksjoner er i samme skala. I dette scenariet skaleres dataene til et område fra 255 til 0 ved å dele på 1, som er et vanlig normaliseringstrinn for bildedata.
Dette fremskynder modellens konvergens og kan øke ytelsen.
X_train = X_train / 255.0
X_test = X_test / 255.0
Opprette modusen
Vi ønsker å identifisere personen hvis ansikt vises på et bilde. I dette tilfellet vil vi bruke et fullt tilkoblet nettverk, ofte kjent som et tett nettverk. Det er et kunstig nevralt nettverk som ble brukt til å lage modellen.
Kunstige nevrale nettverk er modellert etter hvordan den menneskelige hjernen fungerer og er organisert. De består av informasjonsbehandlingsnoder eller nevroner som er koblet sammen. Hvert nevron i et lag i et tett nettverk er knyttet til hvert nevron i laget over det.
Modellen har fire lag i denne koden. For å bli matet inn i det neste laget, blir inndataene flatet i det første laget til en endimensjonal matrise. De 128 og 64 nevronene i de følgende to lagene er følgelig fullstendig koblet.
ReLU-aktiveringsfunksjonen er en unik aktiveringsfunksjon som brukes av disse lagene. Med det kan vi få modellen til å lære ikke-lineære korrelasjoner mellom inngangene og utgangene. Det siste laget bruker softmax-aktiveringsfunksjonen for å lage spådommer. Og det er et fullstendig forbundet lag med så mange nevroner som det er potensielle 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')
])
Sammenstilling av modellen
Modellen er kompilert ved hjelp av «kompiler»-funksjonen. Vi må forberede modellen for opplæring. Så vi vil definere optimalisereren, tapsfunksjonen og beregningene som skal brukes til å vurdere modellen.
Under trening er det optimizeren som har ansvaret for å endre modellens parametere. «Adam»-optimalisatoren er en populær dyplæringsoptimeringsteknikk.
Vi bruker tapsfunksjonen til å vurdere modellens ytelse på treningsdataene. Fordi måletikettene er heltall som reflekterer bildets klasse i stedet for én-hot-kodede vektorer, er tapsfunksjonen "spare categorical crossentropy" gunstig.
Til slutt definerer vi beregningene for å vurdere modellen, i dette tilfellet "nøyaktighet".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Modelltrening
Vi vil bruke "fit"-funksjonen for å trene modellen.
Vi vil levere treningsdata (X-tog) og relaterte etiketter (y-tog), samt angi antall epoker (iterasjoner) som skal kjøres til 10. Treningsprosedyren endrer modellvektene for å redusere tap (forskjellen mellom spådde og reelle etiketter) og forbedre nøyaktigheten til treningsdata.
model.fit(X_train, y_train, epochs=10)
Modellevaluering
Nå må vi vurdere den trente modellen på testdataene. Vi bruker testtapet og testnøyaktigheten brukes til å vurdere modellens ytelse. På testdata X-testen og testetikettene y-testen, må vi kalle "the model.evaluate function"
Funksjonen gir testnøyaktighet og testtap. Variablene test tap og test nøyaktighet, henholdsvis, inneholder disse verdiene. Til slutt bruker vi "print"-funksjonen for å gi testnøyaktigheten.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Forutsi klasser og få de forutsagte klassene
Ved å bruke treningsmodellen og testdataene lager algoritmen spådommer. Når testdataene sendes til "model.predict"-metoden, sender den ut en rekke spådommer for hvert bilde i testsettet.
Målklassenavnet for hvert bilde hentes deretter fra "målnavn"-listen ved å bruke "np.argmax"-funksjonen for å identifisere indeksen med størst forutsagt sannsynlighet. Denne indeksen brukes deretter til å bestemme den predikerte klassen for hvert bilde.
Ved å bruke en listeforståelse blir alle spådommene i "prediksjons"-matrisen utsatt for denne metoden, noe som resulterer i listen "forutsagte klasser".
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualisere spådommene
Vi kan nå se hvordan modellen vår ser ut.
For å evaluere hvor godt modellen gjør det, vil de første 10 bildene og deres spådommer bli vist. Den vil plotte bildene i gråtoner og vise både den faktiske klassen til bildet og klassen forutsagt av modellen ved å bruke matplotlib.pyplot-modulen.
"imshow"-funksjonen brukes av for-løkken til å plotte hvert av de første 10 testsettets bilder. Målnavn[y test[i]] og predikerte klasser[i] brukes til å bestemme henholdsvis bildets faktiske klasse og predikerte klasse. Titlene på hvert plott blir deretter angitt med disse klassifiseringene.
Til slutt vises plottet ved å bruke 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 tilbyr et komplett og fleksibelt miljø for å lage maskinlæringsmodeller.
Ved å finjustere modellen for å møte spesielle krav eller ved å legge til nye utviklinger innen maskinlæring, kan nøyaktigheten til modellen økes ytterligere.
TensorFlow og ansiktsgjenkjenning vil sannsynligvis bli brukt i økende grad i bransjer som sikkerhetssystemer, biometrisk autentisering og helsetjenester i fremtiden. Vi vil snart se fascinerende innovasjoner.
Legg igjen en kommentar