TensorFlow är ett mångsidigt verktyg för att skapa maskininlärningsmodeller.
I det här inlägget kommer vi att titta på hur man skapar ett ansiktsigenkänningssystem med TensorFlow, ett ramverk för maskininlärning med öppen källkod. Vi kommer att gå igenom de väsentliga processerna för att skapa ett framgångsrikt ansiktsigenkänningssystem, från att samla in och förbereda data till att träna och utvärdera en modell.
Du kommer att få förstahandserfarenhet av TensorFlow för att skapa ansiktsigenkänning med hjälp av kodsnuttar och verkliga exempel. Du får gärna följa med när vi går vidare.
Introduktion till TensorFlow
TensorFlow är ett gratis bibliotek med öppen källkod. Det är en symbolisk matematisk verktygslåda som använder dataflöde och differentierbar programmering. Du kan hantera en rad uppgifter med den, inklusive djupgående neurala nätverk utbildning.
TensorFlow är kraftfullt och anpassningsbart. Likaså är det ett bra verktyg för att utveckla och implementera maskininlärningsmodeller. Du kan bygga komplicerade modeller med flera lager och tensoroperationer. Dessutom kan förbyggda modeller i biblioteket finjusteras för specifika behov.
Dessutom har TensorFlow en enorm och växande användargemenskap. Så det finns en uppsjö av information och hjälp för individer som är nya på plattformen.
TensorFlow är populärt för maskininlärning delvis för att det ger ett heltäckande arbetsflöde. Så du kan enkelt konstruera, träna och distribuera modeller. Den tillhandahåller verktyg och strategier för att förbättra och skala modeller för att passa specifika krav. Det varierar från förbearbetning av data till modellinstallation.
Vad är ansiktsigenkänning?
Ansiktsigenkänning är en dator vision uppgift som identifierar en persons identifiering baserat på deras ansikte. Denna teknik känner igen ansiktsdrag, såsom formen och strukturen på ögon, näsa och mun.
Och den jämför dem med en databas med kända ansikten för att identifiera en matchning. Ansiktsigenkänning har flera användningsområden, inklusive säkerhetssystem, fotoorganisation och biometrisk autentisering.
Ansiktsigenkänningsalgoritmernas noggrannhet har ökat avsevärt de senaste åren som ett resultat av genombrott inom maskininlärning.
Importera nödvändiga bibliotek
Innan vi börjar med något måste vi importera de bibliotek som behövs för vår modell. Tensorflow (tf) importeras och används för att skapa och träna modellen. <(p>
"numpy" utför matematiska beräkningar och databearbetning.
"matplotlib.pyplot" importeras som plt och används för datakartläggning och visualiseringar.
Slutligen importeras "hämta lfw människor" från sklearn. datauppsättningar och används för att ladda datauppsättningen för ansiktsigenkänning. Den här funktionen är en del av verktygslådan scikit-learn. Tack vare den här funktionen behövde vi inte ladda upp ytterligare en datauppsättning. Detta är redan inbyggt i sckit-learn.
Och det ger dig tillgång till ett brett utbud av datauppsättningar för maskininlärning applikationer. I det här scenariot använder vi metoden fetch lfw people för att hämta datauppsättningen "Labeled Faces in the Wild" (LFW). Den består av foton av människors ansikten samt de etiketter som följer med dem.
Dessa bibliotek är avgörande för implementeringen och utvärderingen av vår ansiktsigenkänningsmodell.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Förbearbetar och laddar datauppsättningen för ansiktsigenkänning
I den här delen använder vi funktionen "hämta lfw personer" för att förbehandla ansiktsigenkänningsdata. Först använder vi hämta lfw-personer med alternativet "min ansikten per person=60". Detta indikerar att vi bara vill inkludera personer i datasetet som har minst 60 bilder. Därför säkerställer vi att vår modell har tillräckliga data att lära sig. Detta minskar också risken för övermontering.
Data och etiketter från ansiktsobjektet extraheras sedan och tilldelas variablerna X och y. X hol.
Vi är nu redo att träna vår ansiktsigenkänningsmodell med förbearbetade data och etiketter.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Dela upp tränings- och testset
I det här steget delar vi upp vår ansiktsigenkänningsdatauppsättning i två halvor med hjälp av tågtestmetoden från sklearn.model selection. Målet med denna uppdelning är att bedöma vår modells prestanda efter träning
Tågtestdelningsfunktionen accepterar som indata data X och etiketter y. Och den delar upp dem i tränings- och testset. Vi väljer teststorlek=0.2 i detta exempel. Detta innebär att 20 % av data kommer att användas som testset och 80 % som träningsset. Dessutom använder vi random state=42 för att säkerställa att data delas konsekvent varje gång koden utförs.
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)
Förbereder data
Syftet med förbearbetning av data är att förbereda dem för införande i modellen. Data förbehandlas i denna kod genom att dividera varje datapunkt med 255.
Vad motiverade oss att uppnå detta? Normalisering är en förbehandlingsprocedur som används i maskininlärning för att garantera att alla funktioner är i samma skala. I det här scenariot skalas data till ett intervall från 255 till 0 genom att dividera med 1, vilket är ett vanligt normaliseringssteg för bilddata.
Detta påskyndar modellens konvergens och kan öka dess prestanda.
X_train = X_train / 255.0
X_test = X_test / 255.0
Skapa läget
Vi vill identifiera individen vars ansikte syns på en bild. I det här fallet kommer vi att använda ett helt uppkopplat nätverk, ofta känt som ett tätt nätverk. Det är ett artificiellt neuralt nätverk som användes för att skapa modellen.
Artificiella neurala nätverk är modellerade efter hur den mänskliga hjärnan fungerar och är organiserad. De består av informationsbehandlande noder eller neuroner som är länkade. Varje neuron i ett lager i ett tätt nätverk är kopplat till varje neuron i lagret ovanför.
Modellen har fyra lager i denna kod. För att matas in i nästa lager plattas indata till i det första lagret till en endimensionell array. 128- och 64-neuronerna i de följande två skikten är följaktligen helt sammanlänkade.
ReLU-aktiveringsfunktionen är en unik aktiveringsfunktion som används av dessa lager. Med det kan vi få modellen att lära sig icke-linjära korrelationer mellan ingångar och utgångar. Det sista lagret använder softmax-aktiveringsfunktionen för att göra förutsägelser. Och det är ett helt sammankopplat lager med lika många neuroner som det finns potentiella 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')
])
Sammanställning av modellen
Modellen kompileras med hjälp av funktionen "kompilera". Vi måste förbereda modellen för utbildning. Så vi kommer att definiera optimeraren, förlustfunktionen och mätvärdena som kommer att användas för att bedöma modellen.
Under träningen är det optimeraren som har hand om att ändra modellens parametrar. "Adam"-optimeraren är en populär optimeringsteknik för djupinlärning.
Vi använder förlustfunktionen för att bedöma modellens prestanda på träningsdata. Eftersom måletiketterna är heltal som återspeglar bildens klass snarare än enkodade vektorer, är förlustfunktionen "gles kategorisk crossentropy" gynnsam.
Slutligen definierar vi måtten för att bedöma modellen, i detta fall "noggrannhet".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Modellutbildning
Vi kommer att använda "passform"-funktionen för att träna modellen.
Vi kommer att tillhandahålla träningsdata (X-tåg) och relaterade etiketter (y-tåg), samt ställa in antalet epoker (iterationer) som ska köras som 10. Träningsproceduren modifierar modellvikterna för att minska en förlust (skillnaden mellan förutspådda och verkliga etiketter) och förbättra noggrannheten hos träningsdata.
model.fit(X_train, y_train, epochs=10)
Modellutvärdering
Nu måste vi bedöma den tränade modellen på testdata. Vi använder testförlusten och testnoggrannheten används för att bedöma modellens prestanda. På testdata X-testet och testetiketterna y-testet måste vi anropa "the model.evaluate function"
Funktionen matar ut testnoggrannheten och testförlusten. Variablerna testförlust respektive testnoggrannhet innehåller dessa värden. Slutligen använder vi "print"-funktionen för att mata ut testnoggrannheten.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Förutsäga klasser och få de förutspådda klasserna
Med hjälp av träningsmodellen och testdata gör algoritmen förutsägelser. När testdata skickas till metoden "model.predict", matar den ut en rad förutsägelser för varje bild i testsetet.
Målklassnamnet för varje bild hämtas sedan från listan "målnamn" med hjälp av funktionen "np.argmax" för att identifiera indexet med störst förutsagd sannolikhet. Detta index används sedan för att bestämma den förutsagda klassen för varje bild.
Med hjälp av en listförståelse utsätts alla förutsägelser i "förutsägelser"-matrisen för denna metod, vilket resulterar i listan "förutspådda klasser".
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualisera förutsägelserna
Vi kan nu se hur vår modell ser ut.
För att utvärdera hur bra modellen går, kommer de första 10 bilderna och deras förutsägelser att visas. Den kommer att plotta bilderna i gråskala och visa både bildens faktiska klass och klassen som förutspås av modellen med matplotlib.pyplot-modulen.
Funktionen "imshow" används av for-loopen för att plotta var och en av de första 10 testsetfotona. Målnamn[y test[i]] och predikterade klasser[i] används för att bestämma bildens faktiska klass respektive predikterade klass. Tittlarna på varje tomt anges sedan av dessa klassificeringar.
Slutligen visas plottet med metoden plt.show() .
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()
Sammanfatta
TensorFlow erbjuder en komplett och flexibel miljö för att skapa modeller för maskininlärning.
Genom att finjustera modellen för att möta särskilda krav eller genom att lägga till nya utvecklingar inom maskininlärning kan modellens noggrannhet ökas ytterligare.
TensorFlow och ansiktsigenkänning kommer sannolikt att användas alltmer i industrier som säkerhetssystem, biometrisk autentisering och sjukvård i framtiden. Vi kommer att se fascinerande innovationer inom kort.
Kommentera uppropet