TensorFlow este un instrument versatil pentru a crea modele de învățare automată.
În această postare, vom analiza cum să creați un sistem de recunoaștere a feței cu TensorFlow, un cadru de învățare automată open-source. Vom trece peste procesele esențiale în crearea unui sistem de recunoaștere a feței de succes, de la colectarea și pregătirea datelor până la formarea și evaluarea unui model.
Veți obține experiență de primă mână cu TensorFlow pentru a crea recunoaștere facială cu ajutorul fragmentelor de cod și a exemplelor din lumea reală. Sunteți binevenit să urmăriți pe măsură ce procedăm.
Introducere în TensorFlow
TensorFlow este o bibliotecă gratuită și open-source. Este o cutie de instrumente matematică simbolică care utilizează fluxul de date și programarea diferențiabilă. Vă puteți descurca cu o gamă largă de sarcini, inclusiv cele profunde rețele neuronale de formare.
TensorFlow este puternic și adaptabil. De asemenea, este un instrument excelent pentru dezvoltarea și implementarea modelelor de învățare automată. Puteți construi modele complicate cu mai multe straturi și operații tensoare. De asemenea, modelele prefabricate din bibliotecă pot fi reglate fin pentru nevoi specifice.
În plus, TensorFlow are o comunitate de utilizatori uriașă și în expansiune. Deci, există o mulțime de informații și ajutor pentru persoanele care sunt noi pe platformă.
TensorFlow este popular pentru masina de învățare în parte pentru că oferă un flux de lucru end-to-end. Astfel, puteți construi, antrena și implementa cu ușurință modele. Acesta oferă instrumente și strategii pentru îmbunătățirea și scalarea modelelor pentru a se potrivi cerințelor specifice. Acesta variază de la preprocesarea datelor până la implementarea modelului.
Ce este recunoașterea feței?
Recunoașterea feței este a viziunea computerului sarcină care identifică identificarea unei persoane pe baza feței acesteia. Această tehnică recunoaște trăsăturile faciale, cum ar fi forma și textura ochilor, nasului și gurii.
Și le compară cu o bază de date de fețe cunoscute pentru a identifica o potrivire. Recunoașterea feței are mai multe utilizări, inclusiv sistemele de securitate, organizarea fotografiilor și autentificarea biometrică.
Precizia algoritmilor de recunoaștere a feței a crescut substanțial în ultimii ani, ca urmare a progreselor în învățarea automată.
Importul bibliotecilor necesare
Înainte de a începe orice, trebuie să importam bibliotecile necesare modelului nostru. Tensorflow (tf) este importat și utilizat pentru a crea și antrena modelul. <(p>
„numpy” efectuează calcule matematice și prelucrarea datelor.
„matplotlib.pyplot” este importat ca plt și folosit pentru diagrame de date și vizualizări.
În cele din urmă, „fetch lfw people” este importat din sklearn. seturi de date și utilizate pentru a încărca setul de date de recunoaștere facială. Această funcție face parte din setul de instrumente scikit-learn. Datorită acestei funcții, nu a fost nevoie să încărcăm un alt set de date. Acesta este deja construit în sckit-learn.
Și vă oferă acces la o gamă largă de seturi de date pentru învățarea automată aplicatii. În acest scenariu, folosim metoda fetch lfw people pentru a prelua setul de date „Labeled Faces in the Wild” (LFW). Include fotografii ale fețelor oamenilor, precum și etichetele care le însoțesc.
Aceste biblioteci sunt critice în implementarea și evaluarea modelului nostru de recunoaștere a feței.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Preprocesarea și încărcarea setului de date de recunoaștere a feței
În această parte, folosim funcția „preluare persoane lfw” pentru a preprocesa datele de recunoaștere facială. În primul rând, folosim fetch lfw people cu opțiunea „min fețe per persoană=60”. Acest lucru indică faptul că dorim să includem în setul de date doar persoane care au cel puțin 60 de fotografii. Prin urmare, ne asigurăm că modelul nostru are date adecvate de învățat. De asemenea, acest lucru scade pericolul de supraadaptare.
Datele și etichetele din obiectul fețe sunt apoi extrase și atribuite variabilelor X și y. X hol.
Acum suntem pregătiți să ne antrenăm modelul de recunoaștere facială folosind date și etichete preprocesate.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Împărțirea seturi de antrenament și de testare
În acest pas, ne-am împărțit setul de date de recunoaștere a feței în două jumătăți folosind metoda de împărțire a testului de tren din selecția sklearn.model. Scopul acestei împărțiri este de a evalua performanța modelului nostru după antrenament
Funcția de împărțire a testului trenului acceptă ca intrări datele X și etichetele y. Și le împarte în seturi de antrenament și de testare. Selectăm dimensiunea testului=0.2 în acest exemplu. Aceasta înseamnă că 20% din date vor fi utilizate ca set de testare și 80% ca set de antrenament. În plus, folosim stare aleatorie = 42 pentru a ne asigura că datele sunt împărțite în mod consecvent de fiecare dată când este executat codul.
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)
Pregătirea Datelor
Scopul preprocesării datelor este de a le pregăti pentru intrarea în model. Datele sunt preprocesate în acest cod, împărțind fiecare punct de date la 255.
Ce ne-a motivat să realizăm acest lucru? Normalizarea este o procedură de preprocesare utilizată în învățarea automată pentru a garanta că toate caracteristicile sunt la aceeași scară. În acest scenariu, împărțirea la 255 scalează datele la un interval de la 0 la 1, care este un pas obișnuit de normalizare a datelor de imagine.
Acest lucru accelerează convergența modelului și poate crește performanța acestuia.
X_train = X_train / 255.0
X_test = X_test / 255.0
Crearea modului
Dorim să identificăm individul al cărui chip apare într-o imagine. În acest caz, vom folosi o rețea complet conectată, adesea cunoscută ca o rețea densă. Este o rețea neuronală artificială care a fost folosită pentru a crea modelul.
Rețelele neuronale artificiale sunt modelate după modul în care funcționează și este organizat creierul uman. Ele sunt formate din noduri de procesare a informațiilor sau neuroni care sunt legați. Fiecare neuron dintr-un strat dintr-o rețea densă este legat de fiecare neuron din stratul de deasupra acestuia.
Modelul are patru straturi în acest cod. Pentru a fi introduse în următorul strat, datele de intrare sunt aplatizate în primul strat într-o matrice unidimensională. Prin urmare, cei 128 și 64 de neuroni din următoarele două straturi sunt complet legați.
Funcția de activare ReLU este o funcție unică de activare utilizată de aceste straturi. Cu asta, putem face ca modelul să învețe corelații neliniare între intrări și ieșiri. Ultimul strat folosește funcția de activare softmax pentru a face predicții. Și, este un strat complet conectat cu tot atâtea neuroni câte clase potențiale există.
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')
])
Compilarea Modelului
Modelul este compilat folosind funcția „compilare”. Trebuie să pregătim modelul pentru antrenament. Deci, vom defini optimizatorul, funcția de pierdere și valorile care vor fi utilizate pentru a evalua modelul.
În timpul antrenamentului, optimizatorul este responsabil de modificarea parametrilor modelului. Optimizatorul „adam” este o tehnică populară de optimizare a învățării profunde.
Folosim funcția de pierdere pentru a evalua performanța modelului asupra datelor de antrenament. Deoarece etichetele țintă sunt numere întregi care reflectă clasa imaginii, mai degrabă decât vectori codificați one-hot, funcția de pierdere „încrucișată categorică dispersă” este favorabilă.
În cele din urmă, definim metricile pentru a evalua modelul, în acest caz, „acuratețea”.
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Formare model
Vom folosi funcția „fit” pentru a antrena modelul.
Vom furniza datele de antrenament (trenul X) și etichetele aferente (trenul y), precum și setarea numărului de epoci (iterații) de rulat la 10. Procedura de antrenament modifică greutățile modelului pentru a reduce o pierdere (diferența dintre etichete prezise și reale) și îmbunătățirea acurateței datelor de antrenament.
model.fit(X_train, y_train, epochs=10)
Evaluarea modelului
Acum, trebuie să evaluăm modelul antrenat pe datele de testare. Folosim pierderea testului, iar acuratețea testului este folosită pentru a evalua performanța modelului. Pe testul X de date de testare și testul etichetelor de test y, trebuie să numim „funcția model.evaluate”
Funcția emite precizia testului și pierderea testului. Variabilele test pierdere și respectiv precizie test conțin aceste valori. În cele din urmă, folosim funcția „printare” pentru a scoate precizia testului.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Prezicerea claselor și obținerea claselor prezise
Folosind modelul de antrenament și datele de testare, algoritmul face predicții. Când datele de testare sunt transmise la metoda „model.predict”, ea emite o serie de predicții pentru fiecare imagine din setul de testare.
Numele clasei țintă pentru fiecare imagine este apoi preluat din lista „nume țintă” folosind funcția „np.argmax” pentru a identifica indexul cu cea mai mare probabilitate prezisă. Acest index este apoi utilizat pentru a determina clasa prezisă pentru fiecare imagine.
Folosind o listă de înțelegere, toate predicțiile din matricea „predicții” sunt supuse acestei metode, rezultând lista „claselor prezise”.
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Vizualizarea predicțiilor
Acum putem vedea cum arată modelul nostru.
Pentru a evalua cât de bine se descurcă modelul, vor fi afișate primele 10 fotografii și previziunile lor. Acesta va reprezenta fotografiile în tonuri de gri și va afișa atât clasa reală a imaginii, cât și clasa prezisă de model folosind modulul matplotlib.pyplot.
Funcția „imshow” este folosită de bucla for pentru a reprezenta fiecare dintre primele 10 fotografii din set de testare. Numele țintei[y test[i]] și clasele prezise[i] sunt utilizate pentru a determina clasa reală și respectiv clasa prezisă a imaginii. Titlurile fiecărei parcele sunt apoi indicate de aceste clasificări.
În cele din urmă, graficul este afișat folosind metoda 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()
Învelire
TensorFlow oferă un mediu complet și flexibil pentru crearea modelelor de învățare automată.
Prin reglarea fină a modelului pentru a îndeplini cerințele speciale sau prin adăugarea de noi dezvoltări în învățarea automată, precizia modelului poate fi crescută și mai mult.
TensorFlow și recunoașterea facială vor fi probabil folosite din ce în ce mai mult în industrii precum sistemele de securitate, autentificarea biometrică și asistența medicală în viitor. Vom vedea inovații fascinante în curând.
Lasă un comentariu