Ang TensorFlow ay isang maraming nalalaman na tool upang lumikha ng mga modelo ng machine-learning.
Sa post na ito, titingnan natin kung paano gumawa ng face recognition system gamit ang TensorFlow, isang open-source machine learning framework. Tatalakayin natin ang mahahalagang proseso sa paglikha ng isang matagumpay na sistema ng pagkilala sa mukha, mula sa pangangalap at paghahanda ng data upang sanayin at pagtatasa ng isang modelo.
Makakakuha ka ng first-hand na karanasan sa TensorFlow para gumawa ng facial recognition sa tulong ng mga snippet ng code at mga halimbawa sa totoong mundo. Maaari kang sumunod habang nagpapatuloy kami.
Panimula sa TensorFlow
Ang TensorFlow ay isang libre at open-source na library. Ito ay isang symbolic math toolbox na gumagamit ng dataflow at differentiable programming. Maaari mong pangasiwaan ang isang hanay ng mga gawain kasama nito, kabilang ang malalim neural network pagsasanay.
Ang TensorFlow ay makapangyarihan at madaling ibagay. Gayundin, ito ay isang mahusay na tool para sa pagbuo at pag-deploy ng mga modelo ng machine learning. Maaari kang bumuo ng mga kumplikadong modelo na may ilang mga layer at pagpapatakbo ng tensor. Gayundin, ang mga pre-built na modelo sa library ay maaaring maayos para sa mga partikular na pangangailangan.
Higit pa rito, ang TensorFlow ay may malaki at lumalawak na komunidad ng gumagamit. Kaya, mayroong isang kalabisan ng impormasyon at tulong para sa mga indibidwal na bago sa platform.
Ang TensorFlow ay sikat para sa machine learning sa bahagi dahil nagbibigay ito ng end-to-end na daloy ng trabaho. Kaya, madali kang makakagawa, makakapagsanay at makakapag-deploy ng mga modelo. Nagbibigay ito ng mga tool at diskarte para sa pagpapabuti at pag-scale ng mga modelo upang umangkop sa mga partikular na pangangailangan. Nag-iiba ito mula sa paunang pagproseso ng data hanggang sa pag-deploy ng modelo.
Ano ang Face Recognition?
Ang pagkilala sa mukha ay a computer vision gawain na tumutukoy sa pagkakakilanlan ng isang tao batay sa kanilang mukha. Kinikilala ng diskarteng ito ang mga katangian ng mukha, tulad ng hugis at texture ng mga mata, ilong, at bibig.
At, inihahambing ang mga ito sa isang database ng mga kilalang mukha upang makilala ang isang tugma. Ang pagkilala sa mukha ay may ilang gamit, kabilang ang mga sistema ng seguridad, organisasyon ng larawan, at biometric na pagpapatotoo.
Ang katumpakan ng mga algorithm sa pagkilala ng mukha ay tumaas nang malaki sa mga nakaraang taon bilang resulta ng mga tagumpay sa machine learning.
Pag-import ng Mga Kinakailangang Aklatan
Bago simulan ang anumang bagay, kailangan naming i-import ang mga aklatan na kailangan para sa aming modelo. Ang Tensorflow (tf) ay na-import at ginagamit upang likhain at sanayin ang modelo. <(p>
Ang "numpy" ay nagsasagawa ng mga kalkulasyon sa matematika at pagproseso ng data.
Ang “matplotlib.pyplot” ay ini-import bilang plt at ginagamit para sa data charting at visualizations.
Panghuli, ang "fetch lfw people" ay na-import mula sa sklearn. mga dataset at ginamit para i-load ang dataset ng pagkilala sa mukha. Ang function na ito ay bahagi ng scikit-learn toolkit. Salamat sa function na ito hindi namin kinailangang mag-upload ng isa pang dataset. Naka-built na ito sa sckit-learn.
At, binibigyan ka nito ng access sa isang malawak na hanay ng mga dataset para sa machine learning mga aplikasyon. Sa sitwasyong ito, ginagamit namin ang paraan ng fetch lfw people para kunin ang dataset na "Naka-label na Mukha sa Wild" (LFW). Binubuo ito ng mga larawan ng mga mukha ng mga tao pati na rin ang mga label na kasama nila.
Ang mga aklatang ito ay kritikal sa pagpapatupad at pagsusuri ng aming modelo ng pagkilala sa mukha.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Preprocessing at Loading ang Face Recognition Dataset
Sa bahaging ito, ginagamit namin ang function na "kunin ang lfw na mga tao" upang paunang iproseso ang data ng pagkilala sa mukha. Una, ginagamit namin ang pagkuha ng lfw na mga tao na may opsyong "min na mukha bawat tao=60". Isinasaad nito na gusto lang naming isama ang mga tao sa dataset na mayroong hindi bababa sa 60 larawan. Samakatuwid, tinitiyak namin na ang aming modelo ay may sapat na data upang matutunan. Gayundin, pinapababa nito ang panganib ng overfitting.
Ang data at mga label mula sa faces object ay kinukuha at itinalaga sa mga variable na X at y. X hol.
Handa na kaming sanayin ang aming modelo ng pagkilala sa mukha gamit ang preprocessed na data at mga label.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Paghahati ng Mga Set ng Pagsasanay at Pagsusulit
Sa hakbang na ito, hinati namin ang aming dataset ng pagkilala sa mukha sa dalawang hati gamit ang train test split method mula sa pagpili ng sklearn.model. Ang layunin ng hating ito ay upang masuri ang pagganap ng aming modelo pagkatapos ng pagsasanay
Ang train test split function ay tumatanggap bilang input ng data X at mga label na y. At, hinahati nito ang mga ito sa mga set ng pagsasanay at pagsubok. Pinipili namin ang sukat ng pagsubok=0.2 sa halimbawang ito. Ipinahihiwatig nito na 20% ng data ang gagamitin bilang set ng pagsubok at 80% bilang set ng pagsasanay. Higit pa rito, gumagamit kami ng random na estado=42 upang matiyak na ang data ay patuloy na nahahati sa bawat oras na ang code ay isinasagawa.
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)
Paghahanda ng Data
Ang layunin ng preprocessing data ay ihanda ito para sa pagpasok sa modelo. Ang data ay preprocessed sa code na ito sa pamamagitan ng paghahati sa bawat data point sa 255.
Ano ang nag-udyok sa amin upang makamit ito? Ang normalization ay isang paunang pagproseso na pamamaraan na ginagamit sa machine learning para magarantiya na ang lahat ng feature ay nasa parehong sukat. Sa sitwasyong ito, ang paghahati sa 255 ay nagsusukat ng data sa hanay na 0 hanggang 1, na isang karaniwang hakbang sa normalisasyon ng data ng larawan.
Pinapabilis nito ang convergence ng modelo at maaaring mapataas ang pagganap nito.
X_train = X_train / 255.0
X_test = X_test / 255.0
Paglikha ng Mode
Gusto naming kilalanin ang indibidwal na ang mukha ay lumalabas sa isang larawan. Sa kasong ito, gagamit kami ng isang ganap na konektadong network, na kadalasang kilala bilang isang siksik na network. Ito ay isang artipisyal na neural network na ginamit upang lumikha ng modelo.
Ang mga artipisyal na neural network ay itinulad sa kung paano gumagana at naayos ang utak ng tao. Binubuo ang mga ito ng mga node o neuron na nagpoproseso ng impormasyon na naka-link. Ang bawat neuron sa isang layer sa isang siksik na network ay naka-link sa bawat neuron sa layer sa itaas nito.
Ang modelo ay may apat na layer sa code na ito. Upang maipasok sa susunod na layer, ang input data ay i-flatten sa unang layer sa isang one-dimensional na array. Ang 128 at 64 na mga neuron sa sumusunod na dalawang layer, nang naaayon, ay ganap na nakaugnay.
Ang ReLU activation function ay isang natatanging activation function na ginagamit ng mga layer na ito. Sa pamamagitan nito, makukuha natin ang modelo upang matutunan ang mga non-linear na ugnayan sa pagitan ng mga input at output. Ang huling layer ay gumagamit ng softmax activation function upang makagawa ng mga hula. At, ito ay isang ganap na konektadong layer na may kasing dami ng mga neuron na may mga potensyal na klase.
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')
])
Pagsasama-sama ng Modelo
Ang modelo ay pinagsama-sama gamit ang function na "compile". Kailangan nating ihanda ang modelo para sa pagsasanay. Kaya, tutukuyin namin ang optimizer, function ng pagkawala, at mga sukatan na gagamitin upang masuri ang modelo.
Sa panahon ng pagsasanay, ang optimizer ang namamahala sa pagbabago ng mga parameter ng modelo. Ang "adam" optimizer ay isang sikat na deep-learning optimization technique.
Ginagamit namin ang function ng pagkawala upang masuri ang pagganap ng modelo sa data ng pagsasanay. Dahil ang mga target na label ay mga integer na sumasalamin sa klase ng imahe sa halip na mga one-hot na naka-encode na vectors, ang "sparse categorical crossentropy" loss function ay paborable.
Sa wakas, tinutukoy namin ang mga sukatan upang masuri ang modelo, sa kasong ito, "katumpakan."
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Pagsasanay ng Modelo
Gagamitin namin ang function na "fit" para sanayin ang modelo.
Ibibigay namin ang data ng pagsasanay (X train) at mga nauugnay na label (y train), pati na rin ang pagtatakda ng bilang ng mga epoch (iterations) na tatakbo bilang 10. Binabago ng pamamaraan ng pagsasanay ang mga timbang ng modelo upang mabawasan ang pagkawala (ang pagkakaiba sa pagitan hinulaang at totoong mga label) at pagbutihin ang katumpakan ng data ng pagsasanay.
model.fit(X_train, y_train, epochs=10)
Pagsusuri ng Modelo
Ngayon, kailangan nating suriin ang sinanay na modelo sa data ng pagsubok. Ginagamit namin ang pagkawala ng pagsubok at ang katumpakan ng pagsubok ay ginagamit upang masuri ang pagganap ng modelo. Sa test data X test at test labels y test, kailangan nating tawagan ang "model.evaluate function"
Ang function ay naglalabas ng katumpakan ng pagsubok at pagkawala ng pagsubok. Ang mga variable na pagsubok sa pagkawala at katumpakan ng pagsubok, ayon sa pagkakabanggit, ay naglalaman ng mga halagang ito. Panghuli, ginagamit namin ang function na "print" upang i-output ang katumpakan ng pagsubok.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Paghula ng mga Klase at Pagkuha ng mga Hinulaang Klase
Gamit ang modelo ng pagsasanay at ang data ng pagsubok, ang algorithm ay gumagawa ng mga hula. Kapag naipasa ang data ng pagsubok sa pamamaraang "model.predict", naglalabas ito ng hanay ng mga hula para sa bawat larawan sa set ng pagsubok.
Ang pangalan ng target na klase para sa bawat larawan ay kukunin mula sa listahan ng "mga target na pangalan" gamit ang function na "np.argmax" upang matukoy ang index na may pinakamalaking hinulaang posibilidad. Ang index na ito ay ginamit upang matukoy ang hinulaang klase para sa bawat larawan.
Gamit ang isang pag-unawa sa listahan, ang lahat ng mga hula sa hanay ng "mga hula" ay sumasailalim sa paraang ito, na nagreresulta sa listahan ng "mga hinulaang klase."
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Pagsasalarawan sa mga Hula
Nakikita na natin ngayon ang hitsura ng ating modelo.
Upang suriin kung gaano kahusay ang pagganap ng modelo, ang unang 10 larawan at ang kanilang mga hula ay ipapakita. Ilalagay nito ang mga larawan sa grayscale at ipapakita ang parehong aktwal na klase ng imahe at ang klase na hinulaang ng modelo gamit ang matplotlib.pyplot module.
Ang function na "imshow" ay ginagamit ng for loop para i-plot ang bawat isa sa unang 10 test set na larawan. Ang mga target na pangalan[y test[i]] at mga hinulaang klase[i] ay ginagamit upang matukoy ang aktwal na klase ng larawan at hinulaang klase, ayon sa pagkakabanggit. Ang mga pamagat ng bawat plot ay ipinapahiwatig ng mga klasipikasyong ito.
Panghuli, ang plot ay ipinapakita gamit ang plt.show() na paraan.
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()
Balutin
Nag-aalok ang TensorFlow ng kumpleto at flexible na kapaligiran para sa paggawa ng mga modelo ng machine learning.
Sa pamamagitan ng pag-fine-tune ng modelo upang matugunan ang mga partikular na kinakailangan o sa pamamagitan ng pagdaragdag ng mga bagong development sa machine learning, ang katumpakan ng modelo ay maaaring tumaas pa.
Ang TensorFlow at pagkilala sa mukha ay malamang na gagamitin sa mga industriya tulad ng mga sistema ng seguridad, biometric na pagpapatotoo, at pangangalagang pangkalusugan sa hinaharap. Makakakita tayo ng mga kamangha-manghang inobasyon sa ilang sandali.
Mag-iwan ng Sagot