TensorFlow అనేది మెషిన్-లెర్నింగ్ మోడల్లను రూపొందించడానికి ఒక బహుముఖ సాధనం.
ఈ పోస్ట్లో, ఓపెన్ సోర్స్ మెషిన్ లెర్నింగ్ ఫ్రేమ్వర్క్ అయిన టెన్సర్ఫ్లోతో ఫేస్ రికగ్నిషన్ సిస్టమ్ను ఎలా సృష్టించాలో చూద్దాం. మేము ఒక విజయవంతమైన ఫేస్ రికగ్నిషన్ సిస్టమ్ను రూపొందించడంలో అవసరమైన ప్రక్రియలను పరిశీలిస్తాము, డేటాను సేకరించడం మరియు సిద్ధం చేయడం నుండి మోడల్కు శిక్షణ ఇవ్వడం మరియు అంచనా వేయడం వరకు.
కోడ్ స్నిప్పెట్లు మరియు వాస్తవ-ప్రపంచ ఉదాహరణల సహాయంతో ముఖ గుర్తింపును సృష్టించడానికి మీరు TensorFlowతో మొదటి-చేతి అనుభవాన్ని పొందుతారు. మేము కొనసాగిస్తున్నప్పుడు అనుసరించడానికి మీకు స్వాగతం.
టెన్సార్ఫ్లో పరిచయం
TensorFlow అనేది ఉచిత మరియు ఓపెన్ సోర్స్ లైబ్రరీ. ఇది డేటాఫ్లో మరియు డిఫరెన్సిబుల్ ప్రోగ్రామింగ్ని ఉపయోగించే సింబాలిక్ మ్యాథ్ టూల్బాక్స్. మీరు దానితో డీప్తో సహా అనేక రకాల టాస్క్లను నిర్వహించవచ్చు నాడీ నెట్వర్క్ శిక్షణ.
TensorFlow శక్తివంతమైనది మరియు అనుకూలమైనది. అదేవిధంగా, ఇది అభివృద్ధి మరియు అభివృద్ధి కోసం ఒక గొప్ప సాధనం యంత్ర అభ్యాస నమూనాలను అమలు చేయడం. మీరు అనేక లేయర్లు మరియు టెన్సర్ ఆపరేషన్లతో సంక్లిష్టమైన నమూనాలను రూపొందించవచ్చు. అలాగే, లైబ్రరీలో ముందుగా నిర్మించిన నమూనాలు నిర్దిష్ట అవసరాల కోసం చక్కగా ట్యూన్ చేయబడతాయి.
ఇంకా, TensorFlow భారీ మరియు విస్తరిస్తున్న వినియోగదారు సంఘాన్ని కలిగి ఉంది. కాబట్టి, ప్లాట్ఫారమ్కి కొత్తగా వచ్చిన వ్యక్తుల కోసం సమాచారం మరియు సహాయం యొక్క పుష్కలంగా ఉంది.
TensorFlow ప్రసిద్ధి చెందింది యంత్ర అభ్యాసం కొంత భాగం ఎందుకంటే ఇది ఎండ్-టు-ఎండ్ వర్క్ఫ్లోను అందిస్తుంది. కాబట్టి, మీరు నమూనాలను సులభంగా నిర్మించవచ్చు, శిక్షణ పొందవచ్చు మరియు అమలు చేయవచ్చు. ఇది నిర్దిష్ట డిమాండ్లకు సరిపోయేలా మోడల్లను మెరుగుపరచడానికి మరియు స్కేలింగ్ చేయడానికి సాధనాలు మరియు వ్యూహాలను అందిస్తుంది. ఇది డేటా ప్రీ-ప్రాసెసింగ్ నుండి మోడల్ డిప్లాయ్మెంట్ వరకు మారుతుంది.
ఫేస్ రికగ్నిషన్ అంటే ఏమిటి?
ముఖ గుర్తింపు అనేది a కంప్యూటర్ దృష్టి వారి ముఖం ఆధారంగా వ్యక్తి యొక్క గుర్తింపును గుర్తించే పని. ఈ టెక్నిక్ కళ్ళు, ముక్కు మరియు నోటి ఆకారం మరియు ఆకృతి వంటి ముఖ లక్షణాలను గుర్తిస్తుంది.
మరియు, ఇది సరిపోలికను గుర్తించడానికి తెలిసిన ముఖాల డేటాబేస్తో వాటిని పోలుస్తుంది. భద్రతా వ్యవస్థలు, ఫోటో ఆర్గనైజేషన్ మరియు బయోమెట్రిక్ ప్రమాణీకరణతో సహా ముఖ గుర్తింపు అనేక ఉపయోగాలు కలిగి ఉంది.
మెషిన్ లెర్నింగ్లో పురోగతి ఫలితంగా ఇటీవలి సంవత్సరాలలో ఫేస్ రికగ్నిషన్ అల్గారిథమ్ల ఖచ్చితత్వం గణనీయంగా పెరిగింది.
అవసరమైన లైబ్రరీలను దిగుమతి చేస్తోంది
ఏదైనా ప్రారంభించే ముందు, మన నమూనాకు అవసరమైన లైబ్రరీలను దిగుమతి చేసుకోవాలి. Tensorflow (tf) దిగుమతి చేయబడింది మరియు మోడల్ను రూపొందించడానికి మరియు శిక్షణ ఇవ్వడానికి ఉపయోగించబడుతుంది. <(p>
"numpy" గణిత గణనలను మరియు డేటా ప్రాసెసింగ్ను నిర్వహిస్తుంది.
“matplotlib.pyplot” pltగా దిగుమతి చేయబడింది మరియు దీని కోసం ఉపయోగించబడుతుంది డేటా చార్టింగ్ మరియు విజువలైజేషన్.
చివరగా, "fatch lfw people" sklearn నుండి దిగుమతి చేయబడింది. డేటాసెట్లు మరియు ఫేషియల్ రికగ్నిషన్ డేటాసెట్ను లోడ్ చేయడానికి ఉపయోగిస్తారు. ఈ ఫంక్షన్ స్కికిట్-లెర్న్ టూల్కిట్లో భాగం. ఈ ఫంక్షన్కు ధన్యవాదాలు మేము మరొక డేటాసెట్ను అప్లోడ్ చేయాల్సిన అవసరం లేదు. ఇది ఇప్పటికే స్కిట్-లెర్న్లో నిర్మించబడింది.
మరియు, ఇది మీకు విస్తృత శ్రేణికి ప్రాప్యతను ఇస్తుంది మెషిన్ లెర్నింగ్ కోసం డేటాసెట్లు అప్లికేషన్లు. ఈ దృష్టాంతంలో, "లేబుల్డ్ ఫేసెస్ ఇన్ ది వైల్డ్" (LFW) డేటాసెట్ను తిరిగి పొందడానికి మేము lfw పీపుల్ పద్ధతిని పొందుతాము. ఇది వ్యక్తుల ముఖాల ఫోటోలతో పాటు వారితో పాటు వెళ్లే లేబుల్లను కలిగి ఉంటుంది.
ఈ లైబ్రరీలు మా ఫేస్ రికగ్నిషన్ మోడల్ అమలు మరియు మూల్యాంకనంలో కీలకం.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
ఫేస్ రికగ్నిషన్ డేటాసెట్ను ప్రీప్రాసెసింగ్ మరియు లోడ్ చేస్తోంది
ఈ భాగంలో, మేము ఫేషియల్ రికగ్నిషన్ డేటాను ప్రీప్రాసెస్ చేయడానికి “lftw people” ఫంక్షన్ని ఉపయోగిస్తాము. ముందుగా, మేము "min faces per person=60" ఎంపికతో lfw వ్యక్తులను పొందండి. మేము డేటాసెట్లో కనీసం 60 ఫోటోలు కలిగి ఉన్న వ్యక్తులను మాత్రమే చేర్చాలనుకుంటున్నామని ఇది సూచిస్తుంది. అందువల్ల, మా మోడల్లో తెలుసుకోవడానికి తగిన డేటా ఉందని మేము నిర్ధారిస్తాము. అలాగే, ఇది అతిగా సరిపోయే ప్రమాదాన్ని తగ్గిస్తుంది.
ముఖాల వస్తువు నుండి డేటా మరియు లేబుల్లు సంగ్రహించబడతాయి మరియు X మరియు y వేరియబుల్స్కు కేటాయించబడతాయి. X హోల్.
మేము ఇప్పుడు ముందుగా ప్రాసెస్ చేసిన డేటా మరియు లేబుల్లను ఉపయోగించి మా ముఖ గుర్తింపు మోడల్కు శిక్షణ ఇవ్వడానికి సిద్ధంగా ఉన్నాము.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
శిక్షణ మరియు టెస్ట్ సెట్లను విభజించడం
ఈ దశలో, మేము sklearn.model ఎంపిక నుండి రైలు పరీక్ష స్ప్లిట్ పద్ధతిని ఉపయోగించి మా ముఖ గుర్తింపు డేటాసెట్ను రెండు భాగాలుగా విభజించాము. శిక్షణ తర్వాత మా మోడల్ పనితీరును అంచనా వేయడం ఈ విభజన యొక్క లక్ష్యం
రైలు పరీక్ష స్ప్లిట్ ఫంక్షన్ ఇన్పుట్ల డేటా X మరియు y లేబుల్లుగా అంగీకరిస్తుంది. మరియు, ఇది వాటిని శిక్షణ మరియు పరీక్ష సెట్లుగా విభజిస్తుంది. మేము ఈ ఉదాహరణలో పరీక్ష పరిమాణం = 0.2 ఎంచుకోండి. డేటాలో 20% పరీక్ష సెట్గా మరియు 80% శిక్షణ సెట్గా ఉపయోగించబడుతుందని ఇది సూచిస్తుంది. ఇంకా, కోడ్ అమలు చేయబడిన ప్రతిసారీ డేటా స్థిరంగా విభజించబడిందని నిర్ధారించడానికి మేము యాదృచ్ఛిక స్థితి=42ని ఉపయోగిస్తాము.
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)
డేటాను సిద్ధం చేస్తోంది
డేటాను ప్రీప్రాసెసింగ్ చేయడం యొక్క ఉద్దేశ్యం మోడల్లోకి ప్రవేశించడానికి దానిని సిద్ధం చేయడం. ప్రతి డేటా పాయింట్ను 255తో విభజించడం ద్వారా ఈ కోడ్లో డేటా ముందుగా ప్రాసెస్ చేయబడుతుంది.
దీన్ని సాధించడానికి మమ్మల్ని ప్రేరేపించినది ఏమిటి? సాధారణీకరణ అనేది మెషిన్ లెర్నింగ్లో అన్ని ఫీచర్లు ఒకే స్కేల్లో ఉన్నాయని హామీ ఇవ్వడానికి ఉపయోగించే ప్రీప్రాసెసింగ్ విధానం. ఈ దృష్టాంతంలో, 255తో భాగించడం అనేది డేటాను 0 నుండి 1 పరిధికి స్కేల్ చేస్తుంది, ఇది సాధారణ చిత్ర డేటా సాధారణీకరణ దశ.
ఇది మోడల్ యొక్క కన్వర్జెన్స్ను వేగవంతం చేస్తుంది మరియు దాని పనితీరును పెంచుతుంది.
X_train = X_train / 255.0
X_test = X_test / 255.0
మోడ్ను సృష్టిస్తోంది
మేము చిత్రంలో కనిపించే వ్యక్తిని గుర్తించాలనుకుంటున్నాము. ఈ సందర్భంలో, మేము పూర్తిగా కనెక్ట్ చేయబడిన నెట్వర్క్ను ఉపయోగిస్తాము, దీనిని తరచుగా దట్టమైన నెట్వర్క్ అని పిలుస్తారు. ఇది మోడల్ను రూపొందించడానికి ఉపయోగించిన కృత్రిమ నాడీ నెట్వర్క్.
కృత్రిమ న్యూరల్ నెట్వర్క్లు మానవ మెదడు ఎలా పనిచేస్తుందో మరియు ఎలా నిర్వహించబడుతుందో దాని ఆధారంగా రూపొందించబడ్డాయి. అవి సమాచార-ప్రాసెసింగ్ నోడ్లు లేదా అనుసంధానించబడిన న్యూరాన్లతో రూపొందించబడ్డాయి. దట్టమైన నెట్వర్క్లోని పొరలోని ప్రతి న్యూరాన్ దాని పై పొరలోని ప్రతి న్యూరాన్తో అనుసంధానించబడి ఉంటుంది.
ఈ కోడ్లో మోడల్కు నాలుగు లేయర్లు ఉన్నాయి. తదుపరి లేయర్లోకి అందించడానికి, ఇన్పుట్ డేటా మొదటి లేయర్లో ఒక డైమెన్షనల్ శ్రేణిలోకి చదును చేయబడుతుంది. కింది రెండు పొరలలోని 128 మరియు 64 న్యూరాన్లు, తదనుగుణంగా, పూర్తిగా అనుసంధానించబడి ఉన్నాయి.
ReLU యాక్టివేషన్ ఫంక్షన్ అనేది ఈ లేయర్లు ఉపయోగించే ఒక ప్రత్యేకమైన యాక్టివేషన్ ఫంక్షన్. దానితో, ఇన్పుట్లు మరియు అవుట్పుట్ల మధ్య నాన్-లీనియర్ కోరిలేషన్లను తెలుసుకోవడానికి మనం మోడల్ను పొందవచ్చు. చివరి లేయర్ అంచనాలను రూపొందించడానికి సాఫ్ట్మాక్స్ యాక్టివేషన్ ఫంక్షన్ను ఉపయోగిస్తుంది. మరియు, ఇది సంభావ్య తరగతులు ఉన్నన్ని న్యూరాన్లతో పూర్తిగా అనుసంధానించబడిన పొర.
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')
])
మోడల్ కంపైలింగ్
మోడల్ "కంపైల్" ఫంక్షన్ ఉపయోగించి కంపైల్ చేయబడింది. మేము శిక్షణ కోసం నమూనాను సిద్ధం చేయాలి. కాబట్టి, మోడల్ను అంచనా వేయడానికి ఉపయోగించే ఆప్టిమైజర్, లాస్ ఫంక్షన్ మరియు మెట్రిక్లను మేము నిర్వచిస్తాము.
శిక్షణ సమయంలో, మోడల్ యొక్క పారామితులను మార్చడానికి ఆప్టిమైజర్ బాధ్యత వహిస్తాడు. "ఆడమ్" ఆప్టిమైజర్ ఒక ప్రసిద్ధ డీప్-లెర్నింగ్ ఆప్టిమైజేషన్ టెక్నిక్.
శిక్షణ డేటాపై మోడల్ పనితీరును అంచనా వేయడానికి మేము లాస్ ఫంక్షన్ని ఉపయోగిస్తాము. లక్ష్య లేబుల్లు ఒక-హాట్ ఎన్కోడ్ చేసిన వెక్టర్ల కంటే ఇమేజ్ తరగతిని ప్రతిబింబించే పూర్ణాంకాలు కాబట్టి, “స్పేర్స్ కేటగిరికల్ క్రాస్సెంట్రోపీ” లాస్ ఫంక్షన్ అనుకూలంగా ఉంటుంది.
చివరగా, మోడల్ను అంచనా వేయడానికి మేము కొలమానాలను నిర్వచించాము, ఈ సందర్భంలో, "ఖచ్చితత్వం".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
మోడల్ శిక్షణ
మోడల్కు శిక్షణ ఇవ్వడానికి మేము "ఫిట్" ఫంక్షన్ని ఉపయోగిస్తాము.
మేము శిక్షణ డేటా (X రైలు) మరియు సంబంధిత లేబుల్లను (y రైలు) అందిస్తాము, అలాగే యుగాల సంఖ్యను (పునరావృతాలు) 10గా అమలు చేయడానికి సెట్ చేస్తాము. శిక్షణ విధానం నష్టాన్ని తగ్గించడానికి మోడల్ బరువులను సవరిస్తుంది (మధ్య వ్యత్యాసం ఊహించిన మరియు నిజమైన లేబుల్స్) మరియు శిక్షణ డేటా యొక్క ఖచ్చితత్వాన్ని మెరుగుపరచండి.
model.fit(X_train, y_train, epochs=10)
మోడల్ మూల్యాంకనం
ఇప్పుడు, మేము పరీక్ష డేటాపై శిక్షణ పొందిన మోడల్ను అంచనా వేయాలి. మేము పరీక్ష నష్టాన్ని ఉపయోగిస్తాము మరియు మోడల్ పనితీరును అంచనా వేయడానికి పరీక్ష ఖచ్చితత్వం ఉపయోగించబడుతుంది. పరీక్ష డేటా X పరీక్ష మరియు టెస్ట్ లేబుల్స్ y పరీక్షలో, మనం “The model.evaluate function” అని పిలవాలి
ఫంక్షన్ పరీక్ష ఖచ్చితత్వం మరియు పరీక్ష నష్టాన్ని అవుట్పుట్ చేస్తుంది. వేరియబుల్స్ పరీక్ష నష్టం మరియు పరీక్ష ఖచ్చితత్వం, వరుసగా, ఈ విలువలను కలిగి ఉంటాయి. చివరగా, మేము పరీక్ష ఖచ్చితత్వాన్ని అవుట్పుట్ చేయడానికి “ప్రింట్” ఫంక్షన్ని ఉపయోగిస్తాము.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
తరగతులను అంచనా వేయడం మరియు అంచనా వేసిన తరగతులను పొందడం
శిక్షణ నమూనా మరియు పరీక్ష డేటాను ఉపయోగించి, అల్గోరిథం అంచనాలను చేస్తుంది. పరీక్ష డేటా "model.predict" పద్ధతికి పంపబడినప్పుడు, ఇది పరీక్ష సెట్లోని ప్రతి చిత్రం కోసం అంచనాల శ్రేణిని అందిస్తుంది.
ప్రతి చిత్రం కోసం లక్ష్య తరగతి పేరు "np.argmax" ఫంక్షన్ను ఉపయోగించి "లక్ష్య పేర్లు" జాబితా నుండి తిరిగి పొందబడుతుంది, ఇది సూచికను అత్యధికంగా అంచనా వేయబడిన సంభావ్యతతో గుర్తించబడుతుంది. ఈ సూచిక ప్రతి చిత్రం కోసం అంచనా వేసిన తరగతిని నిర్ణయించడానికి ఉపయోగించబడుతుంది.
జాబితా గ్రహణశక్తిని ఉపయోగించి, "అంచనాల" శ్రేణిలోని అన్ని అంచనాలు ఈ పద్ధతికి లోబడి ఉంటాయి, ఫలితంగా "ఊహించిన తరగతులు" జాబితా వస్తుంది.
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
అంచనాలను దృశ్యమానం చేయడం
మన మోడల్ ఎలా ఉందో ఇప్పుడు మనం చూడవచ్చు.
మోడల్ ఎంత బాగా పని చేస్తుందో విశ్లేషించడానికి, మొదటి 10 ఫోటోలు మరియు వాటి అంచనాలు చూపబడతాయి. ఇది ఫోటోలను గ్రేస్కేల్లో ప్లాట్ చేస్తుంది మరియు matplotlib.pyplot మాడ్యూల్ని ఉపయోగించి చిత్రం యొక్క వాస్తవ తరగతి మరియు మోడల్ అంచనా వేసిన తరగతి రెండింటినీ ప్రదర్శిస్తుంది.
మొదటి 10 టెస్ట్ సెట్ ఫోటోలలో ప్రతిదాన్ని ప్లాట్ చేయడానికి ఫర్ లూప్ ద్వారా “imshow” ఫంక్షన్ ఉపయోగించబడుతుంది. లక్ష్య పేర్లు[y పరీక్ష[i]] మరియు అంచనా వేసిన తరగతులు[i] వరుసగా చిత్రం యొక్క వాస్తవ తరగతి మరియు అంచనా వేసిన తరగతిని నిర్ణయించడానికి ఉపయోగించబడతాయి. ప్రతి ప్లాట్ యొక్క శీర్షికలు ఈ వర్గీకరణల ద్వారా సూచించబడతాయి.
చివరగా, ప్లాట్ 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()
సర్ప్ అప్ చేయండి
TensorFlow మెషిన్ లెర్నింగ్ మోడల్లను రూపొందించడానికి పూర్తి మరియు సౌకర్యవంతమైన వాతావరణాన్ని అందిస్తుంది.
నిర్దిష్ట అవసరాలకు అనుగుణంగా మోడల్ను చక్కగా ట్యూన్ చేయడం ద్వారా లేదా మెషిన్ లెర్నింగ్లో కొత్త అభివృద్ధిని జోడించడం ద్వారా, మోడల్ యొక్క ఖచ్చితత్వాన్ని మరింత పెంచవచ్చు.
భవిష్యత్తులో భద్రతా వ్యవస్థలు, బయోమెట్రిక్ ప్రమాణీకరణ మరియు ఆరోగ్య సంరక్షణ వంటి పరిశ్రమలలో టెన్సర్ఫ్లో మరియు ముఖ గుర్తింపు ఎక్కువగా ఉపయోగించబడతాయి. మేము త్వరలో మనోహరమైన ఆవిష్కరణలను చూస్తాము.
సమాధానం ఇవ్వూ