టెన్సార్ ఫ్లో ఇమేజ్ వర్గీకరణ: బిల్డింగ్ వర్గీకరణ గురించి మీరు తెలుసుకోవలసినది

చిత్ర వర్గీకరణ ఒక బిడ్డ కూడా సెకన్లలో చేయగలిగే పని, కానీ ఒక యంత్రం కోసం, ఇటీవలి పురోగతి వరకు ఇది చాలా కష్టమైన పని మరియు లోతైన అభ్యాసం . సెల్ఫ్ డ్రైవింగ్ కార్లు వస్తువులను గుర్తించగలవు మరియు నిజ సమయంలో అవసరమైన చర్య తీసుకోగలవు మరియు వీటిలో ఎక్కువ భాగం సాధ్యమే చిత్ర వర్గీకరణ. ఈ వ్యాసంలో, నేను ఈ క్రింది విషయాల ద్వారా మీకు మార్గనిర్దేశం చేస్తాను:

• టెన్సార్ ఫ్లో అంటే ఏమిటి?
• చిత్ర వర్గీకరణ అంటే ఏమిటి?
• టెన్సార్ ఫ్లో ఇమేజ్ వర్గీకరణ: ఫ్యాషన్ MNIST
• సిఫార్ 10: సిఎన్ఎన్

టెన్సార్ ఫ్లో అంటే ఏమిటి?

టెన్సర్ ఫ్లో డేటాఫ్లో ప్రోగ్రామింగ్ కోసం గూగుల్ యొక్క ఓపెన్ సోర్స్ మెషిన్ లెర్నింగ్ ఫ్రేమ్‌వర్క్. గ్రాఫ్‌లోని నోడ్‌లు గణిత కార్యకలాపాలను సూచిస్తాయి, గ్రాఫ్ అంచులు వాటి మధ్య కమ్యూనికేట్ చేయబడిన బహుళ-డైమెన్షనల్ డేటా శ్రేణులను సూచిస్తాయి.

టెన్సర్‌లు కేవలం బహుమితీయ శ్రేణులు, అధిక పరిమాణంతో డేటాకు 2 డైమెన్షనల్ టేబుల్స్ యొక్క పొడిగింపు. టెన్సార్‌ఫ్లో యొక్క అనేక లక్షణాలు డీప్ లెర్నింగ్‌కు తగినవిగా ఉంటాయి మరియు ఇది ML ఓపెన్ సోర్స్ లైబ్రరీ ML మోడళ్లను అభివృద్ధి చేయడానికి మరియు శిక్షణ ఇవ్వడానికి మీకు సహాయపడుతుంది.

చిత్ర వర్గీకరణ అంటే ఏమిటి?

ఇమేజ్ వర్గీకరణ యొక్క ఉద్దేశ్యం డిజిటల్ ఇమేజ్‌లోని అన్ని పిక్సెల్‌లను అనేక వాటిలో ఒకటిగా వర్గీకరించడం భూమి కవర్ తరగతులు లేదా థీమ్స్ . ఈ వర్గీకరించబడిన డేటా అప్పుడు ఉత్పత్తి చేయడానికి ఉపయోగించబడుతుంది నేపథ్య పటాలు ఒక చిత్రంలో ఉన్న భూమి కవర్.

ఇప్పుడు వర్గీకరణ సమయంలో విశ్లేషకుడు మరియు కంప్యూటర్ మధ్య పరస్పర చర్యపై ఆధారపడి, వర్గీకరణలో రెండు రకాలు ఉన్నాయి:

• పర్యవేక్షించబడింది &
• పర్యవేక్షించబడదు

కాబట్టి, ఏ సమయంలోనైనా వృధా చేయకుండా టెన్సార్ ఫ్లో ఇమేజ్ వర్గీకరణలోకి వెళ్దాం. నాకు 2 ఉదాహరణలు ఉన్నాయి: సులభం మరియు కష్టం. సులభమైన దానితో ముందుకు వెళ్దాం.

టెన్సార్ ఫ్లో ఇమేజ్ వర్గీకరణ: ఫ్యాషన్ MNIST

ఫ్యాషన్ MNIST డేటాసెట్

ఇక్కడ మేము 10 వర్గాలలో 70,000 గ్రేస్కేల్ చిత్రాలను కలిగి ఉన్న ఫ్యాషన్ MNIST డేటాసెట్‌ను ఉపయోగించబోతున్నాము. మేము శిక్షణ కోసం 60000 మరియు పరీక్షా ప్రయోజనాల కోసం 10000 ఉపయోగిస్తాము. మీరు ఫ్యాషన్ MNIST ని నేరుగా టెన్సార్ ఫ్లో నుండి యాక్సెస్ చేయవచ్చు, డేటాను దిగుమతి చేసి లోడ్ చేయండి.

స్కోప్ ఆపరేటర్ సి ++

• ముందుగా లైబ్రరీలను దిగుమతి చేసుకుందాం

__ ఫ్యూచర్__ నుండి సంపూర్ణ_ దిగుమతి, విభజన, ముద్రణ_ఫంక్షన్

• డేటాను లోడ్ చేద్దాం

fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()

• తరువాత, మేము చిత్రాలను తరగతులుగా మ్యాప్ చేయబోతున్నాము

class_names = ['టీ-షర్ట్ / టాప్', 'ట్రౌజర్', 'పుల్లోవర్', 'దుస్తుల', 'కోట్', 'శాండల్', 'షర్ట్', 'స్నీకర్', 'బాగ్', 'చీలమండ బూట్']

• డేటాను అన్వేషించడం

రైలు_చిత్రాలు.ఆకారం 
# ప్రతి లేబుల్ 0-9 మధ్య ఉంటుంది

రైలు_లాబెల్స్ 
test_images.ఆకారం 

• ఇప్పుడు, డేటాను ముందస్తుగా ప్రాసెస్ చేయడానికి సమయం ఆసన్నమైంది.

plt.ఫిగర్() plt.imshow(రైలు_చిత్రాలు[0]) plt.రంగు పట్టీ() plt.గ్రిడ్(తప్పుడు) plt.చూపించు() 
#మీరు శిక్షణా సెట్‌లోని మొదటి చిత్రాన్ని పరిశీలిస్తే, పిక్సెల్ విలువలు 0 నుండి 255 పరిధిలో వస్తాయని మీరు చూస్తారు. 

• చిత్రాలను న్యూరల్ నెట్‌వర్క్‌లోకి ఫీడ్ చేయడానికి 0-1 నుండి స్కేల్ చేయాలి

రైలు_చిత్రాలు = రైలు_చిత్రాలు / 255.0 test_images = test_images / 255.0

• కొన్ని చిత్రాలను ప్రదర్శిద్దాం.

plt.ఫిగర్(figsize=(10,10)) కోసం i లో పరిధి(25): plt.సబ్‌ప్లాట్(5,5,i+ఒకటి) plt.xticks([]) plt.yticks([]) plt.గ్రిడ్(తప్పుడు) plt.imshow(రైలు_చిత్రాలు[i], cmap=plt.సెం.మీ..బైనరీ) plt.xlabel(తరగతి_పేర్లు[రైలు_లాబెల్స్[i]]) plt.చూపించు()

• పొరలను సెటప్ చేయండి

మోడల్ = హార్డ్.సీక్వెన్షియల్([ హార్డ్.పొరలు.చదును(ఇన్పుట్_షాప్=(28, 28)), హార్డ్.పొరలు.దట్టమైన(128, క్రియాశీలత=tf.సంఖ్య.relu), హార్డ్.పొరలు.దట్టమైన(10, క్రియాశీలత=tf.సంఖ్య.సాఫ్ట్‌మాక్స్) ])

• మోడల్‌ను కంపైల్ చేయండి

మోడల్.కంపైల్(ఆప్టిమైజర్='ఆడమ్', నష్టం='sparse_categorical_crossentropy', కొలమానాలు=['ఖచ్చితత్వం'])

• మోడల్ శిక్షణ

మోడల్.సరిపోతుంది(రైలు_చిత్రాలు, రైలు_లాబెల్స్, యుగాలు=10)

• ఖచ్చితత్వాన్ని అంచనా వేస్తుంది

test_loss, test_acc = మోడల్.మూల్యాంకనం(test_images, test_labels) ముద్రణ('పరీక్ష ఖచ్చితత్వం:', test_acc)

• అంచనాలను రూపొందించడం

అంచనాలు = మోడల్.అంచనా వేయండి(test_images)

అంచనాలు[0]

అంచనా అనేది 10 సంఖ్యల శ్రేణి. ప్రతి 10 వేర్వేరు వ్యాసాల చిత్రాలకు అనుగుణంగా ఉండే మోడల్ యొక్క “విశ్వాసం” ఇవి వివరిస్తాయి. ఏ లేబుల్‌లో అత్యధిక విశ్వాస విలువ ఉందో మనం చూడవచ్చు.

ఉదా..అర్గ్మాక్స్(అంచనాలు[0])# మోడల్ ఇది చీలమండ బూట్ అని చాలా నమ్మకంగా ఉంది. ఇది సరైనదా అని చూద్దాం

అవుట్పుట్: 9

test_labels[0]

అవుట్పుట్: 9

• ఇప్పుడు, 10 ఛానెల్‌ల పూర్తి సెట్‌ను చూడవలసిన సమయం వచ్చింది

డెఫ్ plot_image(i, అంచనాలు_అరే, true_label, img): అంచనాలు_అరే, true_label, img = అంచనాలు_అరే[i], true_label[i], img[i] plt.గ్రిడ్(తప్పుడు) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.సెం.మీ..బైనరీ) _హించిన_లేబుల్ = ఉదా..అర్గ్మాక్స్(అంచనాలు_అరే) ఉంటే _హించిన_లేబుల్ == true_label: రంగు = 'ఆకుపచ్చ' లేకపోతే: రంగు = 'నెట్' plt.xlabel('{} {: 2.0f}% ({}) '.ఆకృతి(తరగతి_పేర్లు[_హించిన_లేబుల్], 100*ఉదా..గరిష్టంగా(అంచనాలు_అరే), తరగతి_పేర్లు[true_label]), రంగు=రంగు) డెఫ్ plot_value_array(i, అంచనాలు_అరే, true_label): అంచనాలు_అరే, true_label = అంచనాలు_అరే[i], true_label[i] plt.గ్రిడ్(తప్పుడు) plt.xticks([]) plt.yticks([]) ఈ ప్లాట్ = plt.బార్(పరిధి(10), అంచనాలు_అరే, రంగు='# 777777') plt.ylim([0, ఒకటి]) _హించిన_లేబుల్ = ఉదా..అర్గ్మాక్స్(అంచనాలు_అరే) ఈ ప్లాట్[_హించిన_లేబుల్].set_color('నెట్') ఈ ప్లాట్[true_label].set_color('ఆకుపచ్చ')

• మొదట 0 మరియు 10 వ చిత్రాన్ని చూద్దాం

i = 0 plt.ఫిగర్(figsize=(6,3)) plt.సబ్‌ప్లాట్(ఒకటి,2,ఒకటి) plot_image(i, అంచనాలు, test_labels, test_images) plt.సబ్‌ప్లాట్(ఒకటి,2,2) plot_value_array(i, అంచనాలు, test_labels) plt.చూపించు()

i = 10 plt.ఫిగర్(figsize=(6,3)) plt.సబ్‌ప్లాట్(ఒకటి,2,ఒకటి) plot_image(i, అంచనాలు, test_labels, test_images) plt.సబ్‌ప్లాట్(ఒకటి,2,2) plot_value_array(i, అంచనాలు, test_labels) plt.చూపించు()

• ఇప్పుడు, అనేక చిత్రాలను మరియు వాటి అంచనాలను ప్లాట్ చేద్దాం. సరైనవి ఆకుపచ్చగా ఉంటాయి, తప్పు ఎరుపు రంగులో ఉంటాయి.

num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.ఫిగర్(figsize=(2*2*num_cols, 2*num_rows)) కోసం i లో పరిధి(num_images): plt.సబ్‌ప్లాట్(num_rows, 2*num_cols, 2*i+ఒకటి) plot_image(i, అంచనాలు, test_labels, test_images) plt.సబ్‌ప్లాట్(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, అంచనాలు, test_labels) plt.చూపించు()

• చివరగా, ఒకే చిత్రం గురించి అంచనా వేయడానికి శిక్షణ పొందిన మోడల్‌ను ఉపయోగిస్తాము.

# పరీక్ష డేటాసెట్ నుండి చిత్రాన్ని పట్టుకోండి img = test_images[0] ముద్రణ(img.ఆకారం)

# చిత్రాన్ని మాత్రమే ఉన్న బ్యాచ్‌కు జోడించండి. img = (ఉదా..విస్తరించు_డిమ్స్(img,0)) ముద్రణ(img.ఆకారం)

అంచనాలు_సింగిల్ = మోడల్.అంచనా వేయండి(img) ముద్రణ(అంచనాలు_సింగిల్)

plot_value_array(0, అంచనాలు_సింగిల్, test_labels) plt.xticks(పరిధి(10), తరగతి_పేర్లు, భ్రమణం=నాలుగు ఐదు) plt.చూపించు()

• మీరు బ్యాచ్‌లో మా ఏకైక చిత్రం కోసం అంచనాను చూడవచ్చు.

అంచనా_ ఫలితం = ఉదా..అర్గ్మాక్స్(అంచనాలు_సింగిల్[0])

అవుట్పుట్: 9

c ఆధారంగా జావా

CIFAR-10: CNN

CIFAR-10 డేటాసెట్‌లో విమానాలు, కుక్కలు, పిల్లులు మరియు ఇతర వస్తువులు ఉంటాయి. మీరు చిత్రాలను ముందస్తుగా ప్రాసెస్ చేసి, ఆపై అన్ని నమూనాలలో కన్విలేషనల్ న్యూరల్ నెట్‌వర్క్‌కు శిక్షణ ఇస్తారు. చిత్రాలను సాధారణీకరించాలి మరియు లేబుల్‌లు వన్-హాట్ ఎన్‌కోడ్ కావాలి. ఈ ఉపయోగం కేసు ఖచ్చితంగా టెన్సార్ ఫ్లో ఇమేజ్ వర్గీకరణ గురించి మీ సందేహాలను తొలగిస్తుంది.

• డేటాను డౌన్‌లోడ్ చేస్తోంది

నుండి urllib.request దిగుమతి urlretrieve నుండి os.path దిగుమతి isfile, మసి ఉంది నుండి tqdm దిగుమతి tqdm దిగుమతి టార్ఫైల్ cifar10_dataset_folder_path = 'సిఫార్ -10-బ్యాచ్స్-పై' తరగతి DownloadProgress(tqdm): చివరి_బ్లాక్ = 0 డెఫ్ హుక్(స్వీయ, block_num=ఒకటి, బ్లాక్_సైజ్=ఒకటి, మొత్తం పరిమాణం=ఏదీ లేదు): స్వీయ.మొత్తం = మొత్తం పరిమాణం స్వీయ.నవీకరణ((block_num - స్వీయ.చివరి_బ్లాక్) * బ్లాక్_సైజ్) స్వీయ.చివరి_బ్లాక్ = block_num '' ' డేటా (జిప్) ఫైల్ ఇప్పటికే డౌన్‌లోడ్ చేయబడిందో లేదో తనిఖీ చేయండి లేకపోతే, దీన్ని 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' నుండి డౌన్‌లోడ్ చేసి, సిఫార్ -10-పైథాన్.టార్.జిజ్ గా సేవ్ చేయండి '' ' ఉంటే కాదు isfile('cifar-10-python.tar.gz'): తో DownloadProgress(యూనిట్='బి', యూనిట్_ స్కేల్=నిజం, మినిటర్లు=ఒకటి, desc='CIFAR-10 డేటాసెట్') గా pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.హుక్) ఉంటే కాదు మసి ఉంది(cifar10_dataset_folder_path): తో టార్ఫైల్.తెరిచి ఉంది('cifar-10-python.tar.gz') గా తారు: తారు.అన్నిటిని తీయుము() తారు.దగ్గరగా()

• అవసరమైన లైబ్రరీలను దిగుమతి చేస్తోంది

దిగుమతి pick రగాయ దిగుమతి తిమ్మిరి గా ఉదా. దిగుమతి matplotlib.pyplot గా plt

• డేటాను అర్థం చేసుకోవడం

డేటా యొక్క అసలు బ్యాచ్ 10000 × 3072 టెన్సర్ ఒక సంఖ్యా శ్రేణిలో వ్యక్తీకరించబడింది, ఇక్కడ 10000 అనేది నమూనా డేటా సంఖ్య. చిత్రం రంగు మరియు పరిమాణం 32 × 32. (వెడల్పు x ఎత్తు x num_channel) లేదా (num_channel x వెడల్పు x ఎత్తు) ఆకృతిలో దాణా చేయవచ్చు. లేబుళ్ళను నిర్వచించండి.

డెఫ్ లోడ్_లేబుల్_పేర్లు(): తిరిగి ['విమానం', 'ఆటోమొబైల్', 'పక్షి', 'పిల్లి', 'జింక', 'కుక్క', 'కప్ప', 'గుర్రం', 'ఓడ', 'ట్రక్']

• డేటాను పున hap రూపకల్పన చేస్తోంది

మేము డేటాను రెండు దశల్లో పున hap రూపకల్పన చేయబోతున్నాము

స్కానర్ తరగతిని ఎలా ఉపయోగించాలి

మొదట, అడ్డు వరుస వెక్టర్ (3072) ను 3 ముక్కలుగా విభజించండి. ప్రతి భాగం ప్రతి ఛానెల్‌కు అనుగుణంగా ఉంటుంది. ఇది టెన్సర్ యొక్క (3 x 1024) పరిమాణానికి దారితీస్తుంది. ఫలిత టెన్సర్‌ను మునుపటి దశ నుండి 32 తో విభజించండి. 32 ఇక్కడ చిత్రం యొక్క వెడల్పు అని అర్థం. దీని ఫలితంగా (3x32x32) వస్తుంది.

రెండవది, మేము డేటాను (num_channel, width, height) నుండి (వెడల్పు, ఎత్తు, num_channel) మార్చాలి. దాని కోసం, మేము ట్రాన్స్పోస్ ఫంక్షన్‌ను ఉపయోగించబోతున్నాము.

డెఫ్ load_cfar10_batch(cifar10_dataset_folder_path, batch_id): తో తెరిచి ఉంది(cifar10_dataset_folder_path + '/ డేటా_బ్యాచ్_' + p(batch_id), మోడ్='rb') గా ఫైల్: # ఎన్కోడింగ్ రకం 'లాటిన్ 1' అని గమనించండి బ్యాచ్ = pick రగాయ.లోడ్(ఫైల్, ఎన్కోడింగ్='లాటిన్ 1') లక్షణాలు = బ్యాచ్['సమాచారం'].పున hap రూపకల్పన((లెన్(బ్యాచ్['సమాచారం']), 3, 32, 32)).బదిలీ(0, 2, 3, ఒకటి) లేబుల్స్ = బ్యాచ్['లేబుల్స్'] తిరిగి లక్షణాలు, లేబుల్

• డేటాను అన్వేషించడం

డెఫ్ display_stats(cifar10_dataset_folder_path, batch_id, నమూనా_ఐడి): లక్షణాలు, లేబుల్స్ = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) ఉంటే కాదు (0 <= నమూనా_ఐడి < లెన్(లక్షణాలు)): ముద్రణ('{}బ్యాచ్‌లో నమూనాలు{}.{}పరిధిలో లేదు. '.ఆకృతి(లెన్(లక్షణాలు), batch_id, నమూనా_ఐడి)) తిరిగి ఏదీ లేదు ముద్రణ(' బ్యాచ్ యొక్క గణాంకాలు #{}: '.ఆకృతి(batch_id)) ముద్రణ('# నమూనాలు:{} '.ఆకృతి(లెన్(లక్షణాలు)))) లేబుల్_పేర్లు = లోడ్_లేబుల్_పేర్లు() లేబుల్_ గణనలు = డిక్ట్(జిప్(*ఉదా..ఏకైక(లేబుల్స్, రిటర్న్_కౌంట్లు=నిజం)))) కోసం కీ, విలువ లో లేబుల్_ గణనలు.అంశాలు(): ముద్రణ('లేబుల్ గణనలు [{}] ({}):{}'.ఆకృతి(కీ, లేబుల్_పేర్లు[కీ].ఎగువ(), విలువ)) నమూనా_ఇమేజ్ = లక్షణాలు[నమూనా_ఐడి] నమూనా_లేబుల్ = లేబుల్స్[నమూనా_ఐడి] ముద్రణ(' చిత్రం యొక్క ఉదాహరణ{}: '.ఆకృతి(నమూనా_ఐడి)) ముద్రణ('చిత్రం - కనిష్ట విలువ:{}గరిష్ట విలువ:{}'.ఆకృతి(నమూనా_ఇమేజ్.నిమి(), నమూనా_ఇమేజ్.గరిష్టంగా())) ముద్రణ('చిత్రం - ఆకారం:{}'.ఆకృతి(నమూనా_ఇమేజ్.ఆకారం)) ముద్రణ('లేబుల్ - లేబుల్ ఐడి:{}పేరు:{}'.ఆకృతి(నమూనా_లేబుల్, లేబుల్_పేర్లు[నమూనా_లేబుల్])) plt.imshow(నమూనా_ఇమేజ్)

%matplotlib లైన్ లో %ఆకృతీకరణ ఇన్లైన్ బ్యాకెండ్.ఫిగర్_ఫార్మాట్ = 'రెటీనా' దిగుమతి తిమ్మిరి గా ఉదా. # డేటాసెట్‌ను అన్వేషించండి batch_id = 3 నమూనా_ఐడి = 7000 display_stats(cifar10_dataset_folder_path, batch_id, నమూనా_ఐడి)

• ప్రిప్రాసెసింగ్ విధులను అమలు చేస్తోంది

మేము మిన్-మాక్స్ నార్మలైజేషన్ ద్వారా డేటాను సాధారణీకరించబోతున్నాం. ఇది అన్ని x విలువలను 0 మరియు 1 మధ్య ఉంటుంది.
y = (x-min) / (గరిష్టంగా-నిమిషం)

డెఫ్ సాధారణీకరించండి(x): '' ' వాదన - x: సంఖ్యా శ్రేణిలో ఇన్‌పుట్ ఇమేజ్ డేటా [32, 32, 3] తిరిగి - సాధారణీకరించబడిన x '' ' min_val = ఉదా..నిమి(x) max_val = ఉదా..గరిష్టంగా(x) x = (x-min_val) / (max_val-min_val) తిరిగి x

• వన్-హాట్ ఎన్కోడ్

డెఫ్ one_hot_encode(x): '' ' వాదన - x: లేబుళ్ల జాబితా తిరిగి - ఒక హాట్ ఎన్‌కోడింగ్ మ్యాట్రిక్స్ (లేబుళ్ల సంఖ్య, తరగతి సంఖ్య) '' ' ఎన్కోడ్ చేయబడింది = ఉదా..సున్నాలు((లెన్(x), 10)) కోసం idx, గంటలు లో లెక్కించండి(x): ఎన్కోడ్ చేయబడింది[idx] [గంటలు] = ఒకటి తిరిగి ఎన్కోడ్ చేయబడింది

• డేటాను ప్రాసెస్ చేయండి మరియు సేవ్ చేయండి

డెఫ్ _preprocess_and_save(సాధారణీకరించండి, one_hot_encode, లక్షణాలు, లేబుల్స్, ఫైల్ పేరు): లక్షణాలు = సాధారణీకరించండి(లక్షణాలు) లేబుల్స్ = one_hot_encode(లేబుల్స్) pick రగాయ.డంప్((లక్షణాలు, లేబుల్స్), తెరిచి ఉంది(ఫైల్ పేరు, 'wb')) డెఫ్ preprocess_and_save_data(cifar10_dataset_folder_path, సాధారణీకరించండి, one_hot_encode): n_ బ్యాచ్‌లు = 5 చెల్లుబాటు అయ్యే ఫీచర్లు = [] చెల్లుబాటు అయ్యే_లాబెల్స్ = [] కోసం batch_i లో పరిధి(ఒకటి, n_ బ్యాచ్‌లు + ఒకటి): లక్షణాలు, లేబుల్స్ = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # బ్యాచ్ యొక్క మొత్తం డేటాసెట్ (10%) లో ధ్రువీకరణ డేటాగా సూచికను గుర్తించండి. index_of_validation = పూర్ణాంకానికి(లెన్(లక్షణాలు) * 0.1) # బ్యాచ్ యొక్క మొత్తం డేటాసెట్‌లో 90% ప్రీప్రాసెస్ # - లక్షణాలను సాధారణీకరించండి # - వన్_హోట్_లేబుల్స్ లేబుల్ చేయండి # - 'preprocess_batch_' + batch_number అనే కొత్త ఫైల్‌లో సేవ్ చేయండి # - ప్రతి బ్యాచ్‌కు ప్రతి ఫైల్ _preprocess_and_save(సాధారణీకరించండి, one_hot_encode, లక్షణాలు[:-index_of_validation], లేబుల్స్[:-index_of_validation], 'ప్రిప్రాసెస్_బ్యాచ్_' + p(batch_i) + '.పి') # శిక్షణ డేటాసెట్ కాకుండా, అన్ని బ్యాచ్ డేటాసెట్ ద్వారా ధ్రువీకరణ డేటాసెట్ జోడించబడుతుంది # - బ్యాచ్ యొక్క మొత్తం డేటాసెట్‌లో 10% తీసుకోండి # - వాటిని జాబితాలో చేర్చండి # - చెల్లుబాటు అయ్యే ఫీచర్లు # - చెల్లుబాటు అయ్యే_లాబెల్స్ చెల్లుబాటు అయ్యే ఫీచర్లు.విస్తరించండి(లక్షణాలు[-index_of_validation:)]) చెల్లుబాటు అయ్యే_లాబెల్స్.విస్తరించండి(లేబుల్స్[-index_of_validation:)]) # అన్ని పేర్చబడిన ధ్రువీకరణ డేటాసెట్‌ను ముందే ప్రాసెస్ చేయండి _preprocess_and_save(సాధారణీకరించండి, one_hot_encode, ఉదా..అమరిక(చెల్లుబాటు అయ్యే ఫీచర్లు), ఉదా..అమరిక(చెల్లుబాటు అయ్యే_లాబెల్స్), 'preprocess_validation.p') # పరీక్ష డేటాసెట్‌ను లోడ్ చేయండి తో తెరిచి ఉంది(cifar10_dataset_folder_path + '/ test_batch', మోడ్='rb') గా ఫైల్: బ్యాచ్ = pick రగాయ.లోడ్(ఫైల్, ఎన్కోడింగ్='లాటిన్ 1') # పరీక్ష డేటాను ముందే ప్రాసెస్ చేయండి పరీక్ష_ ఫీచర్లు = బ్యాచ్['సమాచారం'].పున hap రూపకల్పన((లెన్(బ్యాచ్['సమాచారం']), 3, 32, 32)).బదిలీ(0, 2, 3, ఒకటి) test_labels = బ్యాచ్['లేబుల్స్'] # అన్ని ప్రాసెస్ డేటాను ప్రీప్రోసెస్ చేసి సేవ్ చేయండి _preprocess_and_save(సాధారణీకరించండి, one_hot_encode, ఉదా..అమరిక(పరీక్ష_ ఫీచర్లు), ఉదా..అమరిక(test_labels), 'preprocess_training.p')

preprocess_and_save_data(cifar10_dataset_folder_path, సాధారణీకరించండి, one_hot_encode)

• తనిఖీ కేంద్రం

దిగుమతి pick రగాయ చెల్లుబాటు అయ్యే ఫీచర్లు, చెల్లుబాటు అయ్యే_లాబెల్స్ = pick రగాయ.లోడ్(తెరిచి ఉంది('preprocess_validation.p', మోడ్='rb'))

• నెట్‌వర్క్‌ను నిర్మించడం

మొత్తం మోడల్ మొత్తం 14 పొరలను కలిగి ఉంటుంది.

దిగుమతి టెన్సార్ఫ్లో గా tf డెఫ్ conv_net(x, keep_prob): conv1_filter = tf.వేరియబుల్(tf.కత్తిరించబడిన_ సాధారణ(ఆకారం=[3, 3, 3, 64], అర్థం=0, stddev=0.08)) conv2_filter = tf.వేరియబుల్(tf.కత్తిరించబడిన_ సాధారణ(ఆకారం=[3, 3, 64, 128], అర్థం=0, stddev=0.08)) conv3_filter = tf.వేరియబుల్(tf.కత్తిరించబడిన_ సాధారణ(ఆకారం=[5, 5, 128, 256], అర్థం=0, stddev=0.08)) conv4_filter = tf.వేరియబుల్(tf.కత్తిరించబడిన_ సాధారణ(ఆకారం=[5, 5, 256, 512], అర్థం=0, stddev=0.08)) # 1, 2 conv1 = tf.సంఖ్య.conv2d(x, conv1_filter, స్ట్రైడ్స్=[ఒకటి,ఒకటి,ఒకటి,ఒకటి], పాడింగ్='అదే') conv1 = tf.సంఖ్య.relu(conv1) conv1_pool = tf.సంఖ్య.max_pool(conv1, ksize=[ఒకటి,2,2,ఒకటి], స్ట్రైడ్స్=[ఒకటి,2,2,ఒకటి], పాడింగ్='అదే') conv1_bn = tf.పొరలు.batch_normalization(conv1_pool) # 3. 4 conv2 = tf.సంఖ్య.conv2d(conv1_bn, conv2_filter, స్ట్రైడ్స్=[ఒకటి,ఒకటి,ఒకటి,ఒకటి], పాడింగ్='అదే') conv2 = tf.సంఖ్య.relu(conv2) conv2_pool = tf.సంఖ్య.max_pool(conv2, ksize=[ఒకటి,2,2,ఒకటి], స్ట్రైడ్స్=[ఒకటి,2,2,ఒకటి], పాడింగ్='అదే') conv2_bn = tf.పొరలు.batch_normalization(conv2_pool) # 5, 6 conv3 = tf.సంఖ్య.conv2d(conv2_bn, conv3_filter, స్ట్రైడ్స్=[ఒకటి,ఒకటి,ఒకటి,ఒకటి], పాడింగ్='అదే') conv3 = tf.సంఖ్య.relu(conv3) conv3_pool = tf.సంఖ్య.max_pool(conv3, ksize=[ఒకటి,2,2,ఒకటి], స్ట్రైడ్స్=[ఒకటి,2,2,ఒకటి], పాడింగ్='అదే') conv3_bn = tf.పొరలు.batch_normalization(conv3_pool) # 7, 8 conv4 = tf.సంఖ్య.conv2d(conv3_bn, conv4_filter, స్ట్రైడ్స్=[ఒకటి,ఒకటి,ఒకటి,ఒకటి], పాడింగ్='అదే') conv4 = tf.సంఖ్య.relu(conv4) conv4_pool = tf.సంఖ్య.max_pool(conv4, ksize=[ఒకటి,2,2,ఒకటి], స్ట్రైడ్స్=[ఒకటి,2,2,ఒకటి], పాడింగ్='అదే') conv4_bn = tf.పొరలు.batch_normalization(conv4_pool) # 9 ఫ్లాట్ = tf.సహకారం.పొరలు.చదును(conv4_bn) # 10 పూర్తి 1 = tf.సహకారం.పొరలు.పూర్తిగా కనెక్ట్ చేయబడింది(ఇన్పుట్లు=ఫ్లాట్, num_outputs=128, యాక్టివేషన్_ఎఫ్ఎన్=tf.సంఖ్య.relu) పూర్తి 1 = tf.సంఖ్య.వదిలివేయడం(పూర్తి 1, keep_prob) పూర్తి 1 = tf.పొరలు.batch_normalization(పూర్తి 1) # పదకొండు పూర్తి 2 = tf.సహకారం.పొరలు.పూర్తిగా కనెక్ట్ చేయబడింది(ఇన్పుట్లు=పూర్తి 1, num_outputs=256, యాక్టివేషన్_ఎఫ్ఎన్=tf.సంఖ్య.relu) పూర్తి 2 = tf.సంఖ్య.వదిలివేయడం(పూర్తి 2, keep_prob) పూర్తి 2 = tf.పొరలు.batch_normalization(పూర్తి 2) # 12 పూర్తి 3 = tf.సహకారం.పొరలు.పూర్తిగా కనెక్ట్ చేయబడింది(ఇన్పుట్లు=పూర్తి 2, num_outputs=512, యాక్టివేషన్_ఎఫ్ఎన్=tf.సంఖ్య.relu) పూర్తి 3 = tf.సంఖ్య.వదిలివేయడం(పూర్తి 3, keep_prob) పూర్తి 3 = tf.పొరలు.batch_normalization(పూర్తి 3) # 13 పూర్తి 4 = tf.సహకారం.పొరలు.పూర్తిగా కనెక్ట్ చేయబడింది(ఇన్పుట్లు=పూర్తి 3, num_outputs=1024, యాక్టివేషన్_ఎఫ్ఎన్=tf.సంఖ్య.relu) పూర్తి 4 = tf.సంఖ్య.వదిలివేయడం(పూర్తి 4, keep_prob) పూర్తి 4 = tf.పొరలు.batch_normalization(పూర్తి 4) # 14 అవుట్ = tf.సహకారం.పొరలు.పూర్తిగా కనెక్ట్ చేయబడింది(ఇన్పుట్లు=పూర్తి 3, num_outputs=10, యాక్టివేషన్_ఎఫ్ఎన్=ఏదీ లేదు) తిరిగి అవుట్

• హైపారామీటర్లు

యుగాలు = 10 గుంపు పరిమాణం = 128 keep_probability = 0.7 లెర్నింగ్_రేట్ = 0.001

లాజిట్లు = conv_net(x, keep_prob) మోడల్ = tf.గుర్తింపు(లాజిట్లు, పేరు='లాజిట్లు') # పేరు లాగిట్స్ టెన్సర్, తద్వారా శిక్షణ తర్వాత డిస్క్ నుండి లోడ్ అవుతుంది # నష్టం మరియు ఆప్టిమైజర్ ధర = tf.తగ్గించు_మీన్(tf.సంఖ్య.softmax_cross_entropy_with_logits(లాజిట్లు=లాజిట్లు, లేబుల్స్=వై)) ఆప్టిమైజర్ = tf.రైలు.ఆడమ్ ఆప్టిమైజర్(లెర్నింగ్_రేట్=లెర్నింగ్_రేట్).తగ్గించడానికి(ధర) # ఖచ్చితత్వం correct_pred = tf.సమానం(tf.అర్గ్మాక్స్(లాజిట్లు, ఒకటి), tf.అర్గ్మాక్స్(వై, ఒకటి)) ఖచ్చితత్వం = tf.తగ్గించు_మీన్(tf.తారాగణం(correct_pred, tf.ఫ్లోట్ 32), పేరు='ఖచ్చితత్వం')

• న్యూరల్ నెట్‌వర్క్‌కు శిక్షణ ఇవ్వండి

# సింగిల్ ఆప్టిమైజేషన్ 
డెఫ్ రైలు_యూనల్_నెట్ వర్క్(సెషన్, ఆప్టిమైజర్, keep_probability, ఫీచర్_బ్యాచ్, లేబుల్_బ్యాచ్): సెషన్.రన్(ఆప్టిమైజర్, ఫీడ్_డిక్ట్={ x: ఫీచర్_బ్యాచ్, వై: లేబుల్_బ్యాచ్, keep_prob: keep_probability })

# గణాంకాలను చూపుతోంది print_stats(సెషన్, ఫీచర్_బ్యాచ్, లేబుల్_బ్యాచ్, ధర, ఖచ్చితత్వం): నష్టం = sess.రన్(ధర, ఫీడ్_డిక్ట్={ x: ఫీచర్_బ్యాచ్, వై: లేబుల్_బ్యాచ్, keep_prob: ఒకటి. }) చెల్లుబాటు అయ్యే_అక్ = sess.రన్(ఖచ్చితత్వం, ఫీడ్_డిక్ట్={ x: చెల్లుబాటు అయ్యే ఫీచర్లు, వై: చెల్లుబాటు అయ్యే_లాబెల్స్, keep_prob: ఒకటి. }) ముద్రణ('నష్టం:{:> 10.4f}ధ్రువీకరణ ఖచ్చితత్వం:{: .6f}'.ఆకృతి(నష్టం, చెల్లుబాటు అయ్యే_అక్))

• పూర్తి శిక్షణ మరియు మోడల్‌ను సేవ్ చేయడం

డెఫ్ batch_features_labels(లక్షణాలు, లేబుల్స్, గుంపు పరిమాణం): '' ' లక్షణాలను మరియు లేబుల్‌లను బ్యాచ్‌లుగా విభజించండి '' ' కోసం ప్రారంభం లో పరిధి(0, లెన్(లక్షణాలు), గుంపు పరిమాణం): ముగింపు = నిమి(ప్రారంభం + గుంపు పరిమాణం, లెన్(లక్షణాలు)) దిగుబడి లక్షణాలు[ప్రారంభం:ముగింపు], లేబుల్స్[ప్రారంభం:ముగింపు] డెఫ్ load_preprocess_training_batch(batch_id, గుంపు పరిమాణం): '' ' ముందుగా ప్రాసెస్ చేసిన శిక్షణ డేటాను లోడ్ చేసి, వాటిని బ్యాచ్‌లలో లేదా అంతకంటే తక్కువ తిరిగి ఇవ్వండి '' ' ఫైల్ పేరు = 'ప్రిప్రాసెస్_బ్యాచ్_' + p(batch_id) + '.పి' లక్షణాలు, లేబుల్స్ = pick రగాయ.లోడ్(తెరిచి ఉంది(ఫైల్ పేరు, మోడ్='rb')) # శిక్షణ డేటాను పరిమాణం లేదా అంతకంటే తక్కువ బ్యాచ్‌లలో తిరిగి ఇవ్వండి తిరిగి batch_features_labels(లక్షణాలు, లేబుల్స్, గుంపు పరిమాణం)

# మోడల్ మరియు మార్గం ఆదా 
save_model_path = './image_classification' ముద్రణ('శిక్షణ ...') తో tf.సెషన్() గా sess: # వేరియబుల్స్ ప్రారంభిస్తోంది sess.రన్(tf.global_variables_initializer()) # శిక్షణ చక్రం కోసం యుగం లో పరిధి(యుగాలు): # అన్ని బ్యాచ్‌లపై లూప్ చేయండి n_ బ్యాచ్‌లు = 5 కోసం batch_i లో పరిధి(ఒకటి, n_ బ్యాచ్‌లు + ఒకటి): కోసం బ్యాచ్_ ఫీచర్స్, batch_labels లో load_preprocess_training_batch(batch_i, గుంపు పరిమాణం): రైలు_యూనల్_నెట్ వర్క్(sess, ఆప్టిమైజర్, keep_probability, బ్యాచ్_ ఫీచర్స్, batch_labels) ముద్రణ('యుగం{:> 2}, సిఫార్ -10 బ్యాచ్{}: '.ఆకృతి(యుగం + ఒకటి, batch_i), ముగింపు='') print_stats(sess, బ్యాచ్_ ఫీచర్స్, batch_labels, ధర, ఖచ్చితత్వం) # మోడల్‌ను సేవ్ చేయండి సేవర్ = tf.రైలు.సేవర్() సేవ్_పాత్ = సేవర్.సేవ్ చేయండి(sess, save_model_path)

ఇప్పుడు, టెన్సార్ఫ్లో ఇమేజ్ వర్గీకరణ యొక్క ముఖ్యమైన భాగం పూర్తయింది. ఇప్పుడు, మోడల్‌ను పరీక్షించడానికి సమయం ఆసన్నమైంది.

• మోడల్‌ను పరీక్షిస్తోంది

దిగుమతి pick రగాయ దిగుమతి తిమ్మిరి గా ఉదా. దిగుమతి matplotlib.pyplot గా plt నుండి sklearn.preprocessing దిగుమతి లేబుల్ బైనరైజర్ డెఫ్ batch_features_labels(లక్షణాలు, లేబుల్స్, గుంపు పరిమాణం): '' ' లక్షణాలను మరియు లేబుల్‌లను బ్యాచ్‌లుగా విభజించండి '' ' కోసం ప్రారంభం లో పరిధి(0, లెన్(లక్షణాలు), గుంపు పరిమాణం): ముగింపు = నిమి(ప్రారంభం + గుంపు పరిమాణం, లెన్(లక్షణాలు)) దిగుబడి లక్షణాలు[ప్రారంభం:ముగింపు], లేబుల్స్[ప్రారంభం:ముగింపు] డెఫ్ display_image_predictions(లక్షణాలు, లేబుల్స్, అంచనాలు, top_n_ అంచనాలు): n_ క్లాసులు = 10 లేబుల్_పేర్లు = లోడ్_లేబుల్_పేర్లు() లేబుల్_బినారిజర్ = లేబుల్ బైనరైజర్() లేబుల్_బినారిజర్.సరిపోతుంది(పరిధి(n_ క్లాసులు)) లేబుల్_ఐడిలు = లేబుల్_బినారిజర్.విలోమ_ప్రవర్తన(ఉదా..అమరిక(లేబుల్స్)) అత్తి, అక్షాలు = plt.సబ్‌ప్లాట్లు(nrows=top_n_ అంచనాలు, ncols=2, figsize=(ఇరవై, 10)) అత్తి.గట్టి_లేఅవుట్() అత్తి.ఉపశీర్షిక('సాఫ్ట్‌మాక్స్ ప్రిడిక్షన్స్', ఫాంట్ పరిమాణం=ఇరవై, వై=1.1) n_ అంచనాలు = 3 మార్జిన్ = 0.05 ind = ఉదా..ఆరెంజ్(n_ అంచనాలు) వెడల్పు = (ఒకటి. - 2. * మార్జిన్) / n_ అంచనాలు కోసం image_i, (లక్షణం, లేబుల్_ఐడి, pred_indicies, pred_values) లో లెక్కించండి(జిప్(లక్షణాలు, లేబుల్_ఐడిలు, అంచనాలు.సూచీలు, అంచనాలు.విలువలు)): ఉంటే (image_i < top_n_ అంచనాలు): pred_names = [లేబుల్_పేర్లు[pred_i] కోసం pred_i లో pred_indicies] సరైన_పేరు = లేబుల్_పేర్లు[లేబుల్_ఐడి] అక్షాలు[image_i] [0].imshow((లక్షణం*255).astype(ఉదా..int32, కాపీ=తప్పుడు)) అక్షాలు[image_i] [0].set_title(సరైన_పేరు) అక్షాలు[image_i] [0].set_axis_off() అక్షాలు[image_i] [ఒకటి].బార్(ind + మార్జిన్, pred_values[:3], వెడల్పు) అక్షాలు[image_i] [ఒకటి].set_yticks(ind + మార్జిన్) అక్షాలు[image_i] [ఒకటి].set_yticklabels(pred_names[::-ఒకటి]) అక్షాలు[image_i] [ఒకటి].set_xticks([0, 0.5, 1.0])

%matplotlib లైన్ లో %ఆకృతీకరణ ఇన్లైన్ బ్యాకెండ్.ఫిగర్_ఫార్మాట్ = 'రెటీనా' దిగుమతి టెన్సార్ఫ్లో గా tf దిగుమతి pick రగాయ దిగుమతి యాదృచ్ఛిక save_model_path = './image_classification' గుంపు పరిమాణం = 64 n_ నమూనాలు = 10 top_n_ అంచనాలు = 5 డెఫ్ test_model(): పరీక్ష_ ఫీచర్లు, test_labels = pick రగాయ.లోడ్(తెరిచి ఉంది('preprocess_training.p', మోడ్='rb')) లోడ్_గ్రాఫ్ = tf.గ్రాఫ్() తో tf.సెషన్(గ్రాఫ్=లోడ్_గ్రాఫ్) గా sess: # లోడ్ మోడల్ లోడర్ = tf.రైలు.దిగుమతి_మెటా_గ్రాఫ్(save_model_path + '.మెటా') లోడర్.పునరుద్ధరించు(sess, save_model_path) # లోడ్ చేసిన మోడల్ నుండి టెన్సర్‌లను పొందండి లోడ్_ఎక్స్ = లోడ్_గ్రాఫ్.get_tensor_by_name('input_x: 0') లోడ్_వై = లోడ్_గ్రాఫ్.get_tensor_by_name('output_y: 0') లోడ్_కీప్_ప్రోబ్ = లోడ్_గ్రాఫ్.get_tensor_by_name('keep_prob: 0') లోడ్_లాజిట్లు = లోడ్_గ్రాఫ్.get_tensor_by_name('లాజిట్లు: 0') లోడ్_అక్ = లోడ్_గ్రాఫ్.get_tensor_by_name('ఖచ్చితత్వం: 0') # మెమరీ పరిమితుల కోసం బ్యాచ్‌లలో ఖచ్చితత్వాన్ని పొందండి test_batch_acc_total = 0 test_batch_count = 0 కోసం రైలు_ ఫీచర్_బ్యాచ్, రైలు_లేబుల్_బ్యాచ్ లో batch_features_labels(పరీక్ష_ ఫీచర్లు, test_labels, గుంపు పరిమాణం): test_batch_acc_total + = sess.రన్( లోడ్_అక్, ఫీడ్_డిక్ట్={లోడ్_ఎక్స్: రైలు_ ఫీచర్_బ్యాచ్, లోడ్_వై: రైలు_లేబుల్_బ్యాచ్, లోడ్_కీప్_ప్రోబ్: 1.0}) test_batch_count + = ఒకటి ముద్రణ('పరీక్ష ఖచ్చితత్వం:{} '.ఆకృతి(test_batch_acc_total/test_batch_count)) # యాదృచ్ఛిక నమూనాలను ముద్రించండి రాండమ్_టెస్ట్_ ఫీచర్స్, రాండమ్_టెస్ట్_లాబెల్స్ = టుపుల్(జిప్(*యాదృచ్ఛిక.నమూనా(జాబితా(జిప్(పరీక్ష_ ఫీచర్లు, test_labels)), n_ నమూనాలు)))) యాదృచ్ఛిక_ పరీక్ష_ అంచనాలు = sess.రన్( tf.సంఖ్య.top_k(tf.సంఖ్య.సాఫ్ట్‌మాక్స్(లోడ్_లాజిట్లు), top_n_ అంచనాలు), ఫీడ్_డిక్ట్={లోడ్_ఎక్స్: రాండమ్_టెస్ట్_ ఫీచర్స్, లోడ్_వై: రాండమ్_టెస్ట్_లాబెల్స్, లోడ్_కీప్_ప్రోబ్: 1.0}) display_image_predictions(రాండమ్_టెస్ట్_ ఫీచర్స్, రాండమ్_టెస్ట్_లాబెల్స్, యాదృచ్ఛిక_ పరీక్ష_ అంచనాలు, top_n_ అంచనాలు) test_model()

అవుట్పుట్: పరీక్ష ఖచ్చితత్వం: 0.5882762738853503

ఇప్పుడు, మీరు మీ నాడీ నెట్‌వర్క్‌కు ఎక్కువ యుగాలకు శిక్షణ ఇస్తే లేదా యాక్టివేషన్ ఫంక్షన్‌ను మార్చినట్లయితే, మీరు మంచి ఖచ్చితత్వాన్ని కలిగి ఉన్న వేరే ఫలితాన్ని పొందవచ్చు.

కాబట్టి, దీనితో, మేము ఈ టెన్సార్ ఫ్లో ఇమేజ్ వర్గీకరణ వ్యాసం ముగింపుకు వచ్చాము. ఏ విధమైన చిత్రాలను వర్గీకరించడానికి మీరు ఇప్పుడు అదే విధంగా ఉపయోగించవచ్చని నేను ఖచ్చితంగా అనుకుంటున్నాను మరియు మీరు చిత్ర వర్గీకరణకు అనుభవశూన్యుడు కాదు.

ఎడురేకా పైథాన్ సర్టిఫికేషన్ శిక్షణతో పరిశ్రమ అవసరాలు & డిమాండ్ల ప్రకారం పరిశ్రమ నిపుణులచే నిర్వహించబడుతుంది. సాఫ్ట్‌మాక్స్ ఫంక్షన్, ఆటోఎన్‌కోడర్ న్యూరల్ నెట్‌వర్క్‌లు, పరిమితం చేయబడిన బోల్ట్‌జ్మాన్ మెషిన్ (ఆర్‌బిఎం), కేరాస్ & టిఎఫ్‌లెర్న్ వంటి అంశాలను మీరు నేర్చుకుంటారు. ఈ కోర్సును రియల్ టైమ్ కేస్ స్టడీస్‌తో పరిశ్రమ నిపుణులు ప్రత్యేకంగా తీర్చిదిద్దారు.