పైథాన్‌తో డీప్ లెర్నింగ్: బిగినర్స్ డీప్ లెర్నింగ్‌కు గైడ్

2018-19 యొక్క హాటెస్ట్ అంశాలలో ఒకటి మరియు మంచి కారణం కోసం. పరిశ్రమలో చాలా పురోగతులు జరిగాయి, యంత్రాలు లేదా కంప్యూటర్ ప్రోగ్రామ్‌లు వాస్తవానికి మానవులను భర్తీ చేస్తున్న సమయం వచ్చింది. ఇది పైథాన్‌తో డీప్ లెర్నింగ్ డీప్ లెర్నింగ్ అంటే ఏమిటి మరియు ఈ పరివర్తన ఎలా సాధ్యమైందో అర్థం చేసుకోవడానికి వ్యాసం మీకు సహాయం చేస్తుంది. నేను ఈ వ్యాసంలో ఈ క్రింది అంశాలను కవర్ చేస్తాను:

• డేటా సైన్స్ మరియు ఇది భాగాలు
• డీప్ లెర్నింగ్ అవసరం
• డీప్ లెర్నింగ్ అంటే ఏమిటి?
• పెర్సెప్ట్రాన్ మరియు ఆర్టిఫిషియల్ న్యూరల్ నెట్‌వర్క్‌లు
• డీప్ లెర్నింగ్ యొక్క అనువర్తనాలు
• డీప్ లెర్నింగ్ కోసం పైథాన్ ఎందుకు?
• పైథాన్‌తో డీప్ లెర్నింగ్: పెర్సెప్ట్రాన్ ఉదాహరణ
• పైథాన్‌తో డీప్ లెర్నింగ్: డీప్ న్యూరల్ నెట్‌వర్క్‌ను సృష్టించడం

డేటా సైన్స్ మరియు ఇది భాగాలు

బాగా, డేటా సైన్స్ అనేది యుగాలుగా ఉన్న విషయం. డేటా సైన్స్ విభిన్న పద్ధతులు మరియు అల్గోరిథంలను ఉపయోగించడం ద్వారా డేటా నుండి జ్ఞానం వెలికితీత.

మానవ ప్రవర్తనను అనుకరించటానికి యంత్రాలను అనుమతించే ఒక సాంకేతికత. AI వెనుక ఉన్న ఆలోచన చాలా సరళమైనది మరియు మనోహరమైనది, ఇది స్వయంగా నిర్ణయాలు తీసుకోగల తెలివైన యంత్రాలను తయారు చేయడం. కంప్యూటర్లు మానవ మెదడు శక్తికి ఎప్పటికీ సరిపోలవని కొన్నాళ్లుగా భావించారు.

బాగా, అప్పుడు మాకు తగినంత డేటా మరియు గణన శక్తి లేదు, కానీ ఇప్పుడు పెద్ద డేటా ఉనికిలోకి రావడం మరియు GPU ల రాకతో, ఆర్టిఫిషియల్ ఇంటెలిజెన్స్ సాధ్యమే.

AI సాంకేతికత యొక్క ఉపసమితి, ఇది అనుభవంతో మెరుగుపరచడానికి యంత్రాలను ప్రారంభించడానికి గణాంక పద్ధతులను ఉపయోగిస్తుంది.

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

డీప్ లెర్నింగ్ అవసరం

ఆర్టిఫిషియల్ ఇంటెలిజెన్స్ వైపు ఒక దశ యంత్ర అభ్యాసం. మెషిన్ లెర్నింగ్ అనేది AI యొక్క ఉపసమితి మరియు యంత్రాలకు డేటాకు ప్రాప్యత ఇవ్వాలి అనే ఆలోచనపై ఆధారపడి ఉంటుంది మరియు తమను తాము నేర్చుకోవడానికి మరియు అన్వేషించడానికి వదిలివేయాలి. ఇది పెద్ద డేటా సెట్ల నుండి నమూనాల వెలికితీతతో వ్యవహరిస్తుంది. పెద్ద డేటా సెట్‌లను నిర్వహించడం సమస్య కాదు.

• మెషిన్ లెర్నింగ్ అల్గోరిథంలు హై డైమెన్షనల్ డేటాను నిర్వహించలేరు - ఇక్కడ మనకు పెద్ద సంఖ్యలో ఇన్‌పుట్‌లు మరియు అవుట్‌పుట్‌లు ఉన్నాయి: వేల కొలతలు. అటువంటి రకమైన డేటాను నిర్వహించడం మరియు ప్రాసెస్ చేయడం చాలా క్లిష్టంగా మరియు వనరుల సమగ్రంగా మారుతుంది. దీనిని అంటారు డైమెన్షియాలిటీ యొక్క శాపం.

• ఎదుర్కొన్న మరో సవాలు, పేర్కొనడం సేకరించాల్సిన లక్షణాలు . ఫలితాన్ని అంచనా వేయడంలో మరియు మంచి ఖచ్చితత్వాన్ని సాధించడంలో ఇది ముఖ్యమైన పాత్ర పోషిస్తుంది. అందువల్ల, ఫీచర్ వెలికితీత లేకుండా, ప్రోగ్రామర్ కోసం సవాలు పెరుగుతుంది, ఎందుకంటే అల్గోరిథం యొక్క ప్రభావం ప్రోగ్రామర్ ఎంత తెలివైనదో దానిపై ఆధారపడి ఉంటుంది.

ఇప్పుడు, ఇక్కడే డీప్ లెర్నింగ్ రక్షించటానికి వచ్చింది. లోతైన అభ్యాసం అధిక డైమెన్షనల్ డేటాను నిర్వహించగల సామర్థ్యం మరియు కూడా సమర్థవంతంగా పనిచేస్తుంది సరైన లక్షణాలపై దృష్టి పెట్టడం తనంతట తానుగా.

డీప్ లెర్నింగ్ అంటే ఏమిటి?

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

మీకు తెలిసినట్లుగా,మన మెదడు తయారైంది బిలియన్ల న్యూరాన్లు ఇది అద్భుతమైన పనులు చేయడానికి మాకు అనుమతిస్తుంది. ఒక చిన్న పిల్లవాడి మెదడు కూడా సంక్లిష్ట సమస్యలను పరిష్కరించగలదు, ఇది సూపర్-కంప్యూటర్లను ఉపయోగించడం కూడా చాలా కష్టం. కాబట్టి, ఒక ప్రోగ్రామ్‌లో అదే కార్యాచరణను ఎలా సాధించగలం? ఇప్పుడు, ఇక్కడే మనకు అర్థమైంది కృత్రిమ న్యూరాన్ (పెర్సెప్ట్రాన్) మరియు కృత్రిమ న్యూరల్ నెట్‌వర్క్.

పెర్సెప్ట్రాన్ మరియు ఆర్టిఫిషియల్ న్యూరల్ నెట్‌వర్క్‌లు

డీప్ లెర్నింగ్ మెదడు యొక్క ప్రాథమిక యూనిట్‌ను మెదడు కణం లేదా న్యూరాన్ అని పిలుస్తుంది. ఇప్పుడు, జీవ న్యూరాన్ల యొక్క కార్యాచరణను మరియు అవగాహనలో లేదా కృత్రిమ న్యూరాన్లో ఈ కార్యాచరణను ఎలా అనుకరిస్తామో అర్థం చేసుకుందాం.

• డెండ్రైట్: ఇతర న్యూరాన్ల నుండి సంకేతాలను అందుకుంటుంది
• సెల్ బాడీ: అన్ని ఇన్పుట్లను సంకలనం చేస్తుంది
• ఆక్సాన్: ఇది ఇతర కణాలకు సంకేతాలను ప్రసారం చేయడానికి ఉపయోగించబడుతుంది

ఒక కృత్రిమ న్యూరాన్ లేదా a పెర్సెప్ట్రాన్ బైనరీ వర్గీకరణ కోసం ఉపయోగించే సరళ నమూనా. ఇది ఒక న్యూరాన్‌ను మోడల్ చేస్తుంది, ఇది ఇన్‌పుట్‌ల సమితిని కలిగి ఉంటుంది, వీటిలో ప్రతిదానికి ఒక నిర్దిష్ట బరువు ఇవ్వబడుతుంది. న్యూరాన్ వీటిపై కొంత పనితీరును లెక్కిస్తుంది బరువు ఇన్పుట్లను మరియు అవుట్పుట్ను ఇస్తుంది.

ఇది n ఇన్పుట్లను పొందుతుంది (ప్రతి లక్షణానికి అనుగుణంగా). ఇది ఆ ఇన్పుట్లను సంక్షిప్తం చేస్తుంది, పరివర్తనను వర్తింపజేస్తుంది మరియు అవుట్పుట్ను ఉత్పత్తి చేస్తుంది. దీనికి రెండు విధులు ఉన్నాయి:

• సమ్మషన్
• పరివర్తన (సక్రియం)

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

సక్రియం విధులు ఇన్‌పుట్‌లను అవుట్‌పుట్‌లుగా అనువదిస్తుంది. ఇది అవుట్పుట్ను ఉత్పత్తి చేయడానికి ప్రవేశాన్ని ఉపయోగిస్తుంది. యాక్టివేషన్ ఫంక్షన్లుగా ఉపయోగించబడే అనేక విధులు ఉన్నాయి:

• లీనియర్ లేదా ఐడెంటిటీ
• యూనిట్ లేదా బైనరీ దశ
• సిగ్మోయిడ్ లేదా లాజిస్టిక్
• తన్హ్
• రెలు
• సాఫ్ట్‌మాక్స్

బాగా. పెర్సెప్ట్రాన్ సమస్యను పరిష్కరిస్తుందని మీరు అనుకుంటే, మీరు తప్పు. రెండు ప్రధాన సమస్యలు ఉన్నాయి:

• సింగిల్-లేయర్ పెర్సెప్ట్రాన్స్ సరళంగా వేరు చేయలేని డేటా పాయింట్లను వర్గీకరించలేరు .
• సంక్లిష్ట సమస్యలు, ఇందులో ఉంటాయి పారామితులు చాలా సింగిల్-లేయర్ పెర్సెప్ట్రాన్స్ ద్వారా పరిష్కరించబడదు.

ఇక్కడ ఉదాహరణ మరియు మార్కెటింగ్ బృందం నిర్ణయం తీసుకోవటానికి సంబంధించిన పారామితులతో సంక్లిష్టతను పరిగణించండి.

డెవోప్స్ టూల్స్ యొక్క ఆవర్తన పట్టిక

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

• ఇన్పుట్ నోడ్స్ బయటి ప్రపంచం నుండి నెట్‌వర్క్‌కు సమాచారాన్ని అందించండి మరియు వాటిని “ఇన్‌పుట్ లేయర్” అని పిలుస్తారు.
• దాచిన నోడ్స్ గణనలను నిర్వహించండి మరియు ఇన్పుట్ నోడ్ల నుండి అవుట్పుట్ నోడ్లకు సమాచారాన్ని బదిలీ చేయండి. దాచిన నోడ్‌ల సమాహారం “హిడెన్ లేయర్” ను ఏర్పరుస్తుంది.
• అవుట్పుట్ నోడ్స్ సమిష్టిగా “అవుట్‌పుట్ లేయర్” గా సూచిస్తారు మరియు గణనలకు మరియు నెట్‌వర్క్ నుండి సమాచారాన్ని బయటి ప్రపంచానికి బదిలీ చేయడానికి బాధ్యత వహిస్తారు.

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

డీప్ లెర్నింగ్ యొక్క అనువర్తనాలు

పరిశ్రమలో డీప్ లెర్నింగ్ యొక్క వివిధ అనువర్తనాలు ఉన్నాయి, ఇక్కడ మా రోజువారీ పనులలో కొన్ని ముఖ్యమైనవి ఉన్నాయి.

• మాటలు గుర్తుపట్టుట

• యంత్ర అనువాదం

• ముఖ గుర్తింపు మరియు ఆటోమేటిక్ టాగింగ్

• వర్చువల్ పర్సనల్ అసిస్టెంట్లు

• సెల్ఫ్ డ్రైవింగ్ కార్

• చాట్‌బాట్‌లు

డీప్ లెర్నింగ్ కోసం పైథాన్ ఎందుకు?

• ఒక ప్రత్యేకమైన లక్షణాన్ని కలిగి ఉన్న అటువంటి సాధనం a సాధారణ ప్రయోజన ప్రోగ్రామింగ్ భాష ఉండటం ఉపయోగించడానికి సులభం విశ్లేషణాత్మక మరియు పరిమాణాత్మక కంప్యూటింగ్ విషయానికి వస్తే.
• అది చాలా అర్థం చేసుకోవడం సులభం
• పైథాన్ డైనమిక్‌గా టైప్ చేయబడింది
• భారీ
• వంటి వివిధ ప్రయోజనాల కోసం విస్తారమైన లైబ్రరీలు నంపీ, సీబోర్న్, మాట్‌ప్లోట్లిబ్, పాండాలు మరియు స్కికిట్-లెర్న్

ఇప్పుడు తగినంత సిద్ధాంతం, పైథాన్‌తో డీప్ లెర్నింగ్‌ను చిన్న మరియు ఉత్తేజకరమైన ఉదాహరణతో ఎలా ప్రారంభించవచ్చో చూద్దాం.

పైథాన్‌తో డీప్ లెర్నింగ్: పెర్సెప్ట్రాన్ ఉదాహరణ

ఇప్పుడు మీరు ఖచ్చితంగా “అబ్బాయిలు” లేదా ” గేట్. అవుట్పుట్ ఒకటి ఏదైనా ఇన్పుట్లు కూడా ఉంటే ఒకటి.

అందువల్ల, పెర్సెప్ట్రాన్‌ను సెపరేటర్‌గా లేదా OR గేట్ యొక్క ఇన్‌పుట్ సెట్‌ను రెండు తరగతులుగా విభజించే నిర్ణయ రేఖగా ఉపయోగించవచ్చు:

క్లాస్ 1: అవుట్పుట్ 0 గా ఉన్న ఇన్పుట్లు నిర్ణయ రేఖకు దిగువన ఉంటాయి.
క్లాస్ 2: అవుట్పుట్ 1 గా ఉన్న ఇన్పుట్లు నిర్ణయ రేఖ లేదా సెపరేటర్ పైన ఉంటాయి.

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

గణితశాస్త్రంలో ఒక పర్సెప్ట్రాన్ బరువులు, ఇన్‌పుట్‌లు మరియు బయాస్‌ల సమీకరణం వలె భావించవచ్చు.

దశ 1: అవసరమైన అన్ని లైబ్రరీని దిగుమతి చేయండి

ఇక్కడ నేను ఒక లైబ్రరీని మాత్రమే దిగుమతి చేయబోతున్నాను, అనగా. టెన్సర్ ఫ్లో

టెన్సార్‌ఫ్లోను tf గా దిగుమతి చేయండి

దశ 2: ఇన్పుట్ మరియు అవుట్పుట్ కోసం వెక్టర్ వేరియబుల్స్ను నిర్వచించండి

తరువాత, పెర్సెప్ట్రాన్ కోసం ఇన్పుట్, అవుట్పుట్ మరియు బయాస్ నిల్వ చేయడానికి మేము వేరియబుల్స్ సృష్టించాలి.

train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]

దశ 3: బరువు వేరియబుల్ నిర్వచించండి

ఇక్కడ మన బరువులు 3 × 1 ఆకారం యొక్క టెన్సర్ వేరియబుల్‌ను నిర్వచిస్తాము మరియు ప్రారంభంలో దీనికి కొన్ని యాదృచ్ఛిక విలువలను కేటాయిస్తాము.

w = tf.Variable (tf.random_normal ([3, 1], సీడ్ = 15%)

దశ 4: ఇన్పుట్ మరియు అవుట్పుట్ కోసం ప్లేస్హోల్డర్లను నిర్వచించండి

మేము ప్లేస్‌హోల్డర్‌లను నిర్వచించాల్సిన అవసరం ఉంది, తద్వారా వారు రన్‌లో బాహ్య ఇన్‌పుట్‌లను అంగీకరించగలరు.

x = tf.placeholder (tf.float32, [ఏదీ లేదు, 3]) y = tf.placeholder (tf.float32, [ఏదీ లేదు, 1])

దశ 5: అవుట్పుట్ మరియు యాక్టివేషన్ ఫంక్షన్‌ను లెక్కించండి

ఇంతకుముందు చర్చించినట్లుగా, పెర్సెప్ట్రాన్ అందుకున్న ఇన్పుట్ మొదట సంబంధిత బరువులతో గుణించబడుతుంది మరియు తరువాత, ఈ బరువున్న ఇన్పుట్లన్నీ కలిసి ఉంటాయి. తుది ఫలితాన్ని పొందటానికి ఈ సంక్షిప్త విలువ క్రియాశీలతకు ఇవ్వబడుతుంది.

అవుట్పుట్ = tf.nn.relu (tf.matmul (x, w))

గమనిక: ఈ సందర్భంలో, నేను ఉపయోగించాను relu నా యాక్టివేషన్ ఫంక్షన్. మీ అవసరానికి అనుగుణంగా ఏదైనా ఆక్టివేషన్ ఫంక్షన్లను ఉపయోగించడానికి మీకు స్వేచ్ఛ ఉంది.

దశ 6: ఖర్చు లేదా లోపాన్ని లెక్కించండి

పెర్సెప్ట్రాన్ అవుట్పుట్ మరియు కావలసిన అవుట్పుట్ యొక్క వ్యత్యాసం యొక్క చదరపు తప్ప మరేమీ కాదు కాస్ట్ = మీన్ స్క్వేర్డ్ ఎర్రర్ ను మనం లెక్కించాలి.

నష్టం = tf.reduce_sum (tf.square (అవుట్పుట్ - y))

దశ 7: కనిష్టీకరించు లోపం

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

ఆప్టిమైజర్ = tf.train.GradientDescentOptimizer (0.01) రైలు = ఆప్టిమైజర్.మినిమైజ్ (నష్టం)

దశ 8: అన్ని వేరియబుల్స్ ప్రారంభించండి

వేరియబుల్స్ తో మాత్రమే నిర్వచించబడతాయి tf. వేరియబుల్. కాబట్టి, మనం నిర్వచించిన వేరియబుల్స్ ను ప్రారంభించాలి.

సేల్స్ఫోర్స్ సర్వీస్ క్లౌడ్ అంటే ఏమిటి

init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)

దశ 9: పునరావృతాలలో పెర్సెప్ట్రాన్ శిక్షణ

లోపం లేదా నష్టాన్ని తగ్గించడానికి మన పెర్సెప్ట్రాన్‌కు అనగా వరుస పునరావృతంలో బరువులు మరియు పక్షపాతం యొక్క నవీకరణ విలువలను శిక్షణ ఇవ్వాలి. ఇక్కడ, నేను మా పెర్సెప్ట్రాన్ను 100 యుగాలలో శిక్షణ ఇస్తాను.

నేను పరిధిలో (100): sess.run (రైలు, {x: train_in, y: train_out}) ఖర్చు = sess.run (నష్టం, ఫీడ్_డిక్ట్ = {x: రైలు_ఇన్, y: రైలు_అవుట్}) ముద్రణ ('యుగం - ', i,' - నష్టం - ', ఖర్చు)

దశ 10: అవుట్పుట్

……

……

మీరు ఇక్కడ చూడగలిగినట్లుగా, నష్టం ప్రారంభమైంది 2.07 మరియు వద్ద ముగిసింది 0.27

.

పైథాన్‌తో డీప్ లెర్నింగ్: డీప్ న్యూరల్ నెట్‌వర్క్‌ను సృష్టించడం

ఇప్పుడు మేము విజయవంతంగా పెర్సెప్ట్రాన్ను సృష్టించి, OR గేట్ కోసం శిక్షణ ఇచ్చాము. ఈ కథనాన్ని కొనసాగిద్దాం మరియు స్క్రాచ్ నుండి మన స్వంత న్యూరల్ నెట్‌వర్క్‌ను ఎలా సృష్టించవచ్చో చూద్దాం, ఇక్కడ మేము ఇన్‌పుట్ లేయర్, హిడెన్ లేయర్స్ మరియు అవుట్‌పుట్ లేయర్‌ను సృష్టిస్తాము.

మేము MNIST డేటా-సెట్‌ను ఉపయోగించబోతున్నాము. MNIST డేటా-సెట్ కలిగి ఉంటుంది 60,000 శిక్షణ నమూనాలు మరియు 10,000 పరీక్ష చేతితో రాసిన అంకెల చిత్రాల నమూనాలు. చిత్రాలు పరిమాణం కలిగి ఉంటాయి 28 × 28 పిక్సెళ్ళు మరియు అవుట్పుట్ మధ్య ఉంటుంది 0-9 .

చిత్రంలోని అంకెను ఖచ్చితంగా గుర్తించగలిగే మోడల్‌కు శిక్షణ ఇవ్వడం ఇక్కడ పని

మొదట, పైథాన్ 3 నుండి ప్రింట్ ఫంక్షన్‌ను పైథాన్ 2.6+ లోకి తీసుకురావడానికి మేము దిగువ దిగుమతిని ఉపయోగించబోతున్నాము. __ ఫ్యూచర్__ స్టేట్‌మెంట్‌లు ఫైల్ పైభాగంలో ఉండాలి ఎందుకంటే అవి భాష గురించి ప్రాథమిక విషయాలను మారుస్తాయి, కాబట్టి కంపైలర్ వాటి గురించి మొదటి నుండి తెలుసుకోవాలి

__ ఫ్యూచర్__ దిగుమతి ప్రింట్_ఫంక్షన్ నుండి

అడుగడుగునా వ్యాఖ్యలతో కూడిన కోడ్ క్రింది ఉంది

# Tensorflow.examples.tutorials.mnist నుండి MNIST డేటాను దిగుమతి చేయండి ఇన్పుట్_డేటా mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = true) tf దిగుమతి teporflow ను tf దిగుమతి matplotlib.pyplot గా plt # పారామితులు learning_poch = 0.001 శిక్షణ_ batch_size = 100 display_step = 1 # నెట్‌వర్క్ పారామితులు n_hidden_1 = 256 # 1 వ పొర లక్షణాల సంఖ్య n_hidden_2 = 256 # 2 వ పొర లక్షణాల సంఖ్య n_input = 784 # MNIST డేటా ఇన్పుట్ (img ఆకారం: 28 * 28) n_classes = 10 # MNIST మొత్తం తరగతులు ( 0-9 అంకెలు) # tf గ్రాఫ్ ఇన్పుట్ x = tf.placeholder ('ఫ్లోట్', [ఏదీ లేదు, n_input]) y = tf.placeholder ('ఫ్లోట్', [ఏదీ లేదు, n_classes]) # మోడల్ డెఫ్ మల్టీలేయర్_పెర్సెప్ట్రాన్ (x, బరువులు , పక్షపాతం): # RELU యాక్టివేషన్ లేయర్‌తో దాచిన పొర_1 = tf.add (tf.matmul (x, బరువులు ['h1']), పక్షపాతాలు ['b1']) layer_1 = tf.nn.relu (layer_1) # దాచిన పొర RELU యాక్టివేషన్ లేయర్‌తో_ tf.add (tf.matmul (layer_1, బరువులు ['h2']), పక్షపాతాలు ['b2']) layer_2 = tf.nn.relu (layer_2) # సరళ క్రియాశీలతతో అవుట్‌పుట్ లేయర్_ట్లేయర్ = tf. matmul (పొర _2, బరువులు ['అవుట్']) + పక్షపాతాలు ['అవుట్'] రిటర్న్ అవుట్_లేయర్ # స్టోర్ లేయర్స్ బరువు & బయాస్ బరువులు = {'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])), 'h2' : tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_hidden_2, n_classes]))} biases = {'b1': tf.Variable (tf. రాండమ్_నార్మల్ ([n_hidden_1])), 'b2': tf.Variable (tf.random_normal ([n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_classes]))} # మోడల్‌ను నిర్మించండి pred = multilayer_perceptron (x, బరువులు, పక్షపాతాలు) # నష్టం మరియు ఆప్టిమైజర్ ఖర్చును నిర్వచించండి = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate). తగ్గించు (ఖర్చు) # వేరియబుల్స్ ప్రారంభించడం init = tf.global_variables_initializer () # ఖర్చు చరిత్ర మరియు ఖచ్చితత్వ చరిత్రను నిల్వ చేయడానికి ఖాళీ జాబితాను సృష్టించండి cost_history = [] ఖచ్చితత్వం_ చరిత్ర = [] # tf.Session () తో గ్రాఫ్‌ను sess: sess.run (init ) # పరిధిలో యుగం కోసం శిక్షణ చక్రం (శిక్షణ_ఎపోచ్‌లు): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # నేను పరిధిలో ఉన్న అన్ని బ్యాచ్‌లపై లూప్ (మొత్తం_బ్యాచ్): batch_x, batch_y = mnist.train.next_batch (batch_size) # రన్ ఆప్టిమైజేషన్ ఆప్ (బ్యాక్‌ప్రాప్) మరియు ఖర్చు op (నష్ట విలువను పొందడానికి) _, c = sess.run ([ఆప్టిమైజర్, ఖర్చు], ఫీడ్_డిక్ట్ = {x: batch_x, y: batch_y}) # సగటు నష్టాన్ని లెక్కించండి avg_cost + = c / total_batch # ఒక యుగం దశకు లాగ్‌లను ప్రదర్శిస్తే epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # ఖచ్చితత్వం ఖచ్చితత్వాన్ని లెక్కించండి = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = ఖచ్చితత్వం.ఈవల్ ({x: mnist.test.images, y: mnist.test.labels}) # జాబితాకు ఖచ్చితత్వాన్ని జోడించండి ఖచ్చితత్వం_హిస్టరీ.అప్పెండ్ (acu_temp) # ఖర్చు చరిత్రను జోడించండి cost_history.append (avg_cost) ('యుగం:', '% 04d'% (యుగం + 1), '- ఖర్చు =', '{: .9f}'. ఫార్మాట్ (avg_cost), '- ఖచ్చితత్వం =', acu_temp) ముద్రణ ('ఆప్టిమైజేషన్ పూర్తయింది! ') # ఖర్చు చరిత్రను ప్లాట్ చేయండి plt.plot (cost_history) plt.show () # ప్లాట్ ఖచ్చితత్వ చరిత్ర plt.plot (ఖచ్చితత్వం _ చరిత్ర) plt.show () # టెస్ట్ మోడల్ correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # ఖచ్చితత్వాన్ని లెక్కించండి = tf.reduce_mean (tf.cast (correct_prediction, ' ఫ్లోట్ ')) ముద్రణ (' ఖచ్చితత్వం: ', ఖచ్చితత్వం.ఈవల్ ({x: mnist.test.images, y: mnist.test.labels}))

అవుట్పుట్:

ఇప్పుడు దీనితో, పైథాన్ కథనంతో ఈ డీప్ లెర్నింగ్ చివరికి వచ్చాము. డీప్ లెర్నింగ్ యొక్క వివిధ భాగాల గురించి మీకు అవగాహన వచ్చిందని నేను నమ్ముతున్నాను, ఇవన్నీ ఎలా ప్రారంభమయ్యాయి మరియు పైథాన్ ఉపయోగించి మేము ఒక సాధారణ పెర్సెప్ట్రాన్ మరియు డీప్ న్యూరల్ నెట్‌వర్క్‌ను ఎలా సృష్టించగలం.

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

మాకు ప్రశ్న ఉందా? దయచేసి దీనిని 'పైథాన్‌తో డీప్ లెర్నింగ్' యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము మీ వద్దకు తిరిగి వస్తాము.