ఉదాహరణతో బిగినర్స్ కోసం R లో మెషిన్ లెర్నింగ్

R తో యంత్ర అభ్యాసం

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

“మెషిన్ లెర్నింగ్ విత్ R” లోని ఈ బ్లాగ్ ఈ విభాగాలను కలిగి ఉంటుంది:

• యంత్ర అభ్యాసాన్ని అర్థం చేసుకోవడం
• యంత్ర అభ్యాస అల్గోరిథంల రకాలు
• R తో మెషిన్ లెర్నింగ్ అల్గోరిథంలను అమలు చేయడం

R తో యంత్ర అభ్యాసం ఎడురేకా

యంత్ర అభ్యాసాన్ని అర్థం చేసుకోవడం

అవన్నీ చేపలు అని మీకు ఎలా తెలుసు?

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

మన మెదడు ఎలా పనిచేస్తుంది కాని యంత్రం గురించి ఏమిటి? అదే చిత్రాన్ని ఒక యంత్రానికి తినిపించినట్లయితే, యంత్రం దానిని చేప అని ఎలా గుర్తిస్తుంది?

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

ఒక చేపతో అనుబంధించబడిన అన్ని లక్షణాలను యంత్రం తెలుసుకున్న తర్వాత, అది ఎంత నేర్చుకుందో తెలుసుకోవడానికి మేము దానిని క్రొత్త డేటాను తింటాము.

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

పైథాన్‌లో __init__ అంటే ఏమిటి

R బ్లాగుతో ఈ మెషిన్ లెర్నింగ్‌లో ముందుకు వెళ్దాం మరియు మెషిన్ లెర్నింగ్ రకాలను గురించి అర్థం చేసుకుందాం.

యంత్ర అభ్యాస రకాలు

• పర్యవేక్షించబడిన అభ్యాసం:

పర్యవేక్షించబడిన అభ్యాస అల్గోరిథం తెలిసిన డేటా-సెట్ (ట్రైనింగ్ డేటా) నుండి నేర్చుకుంటుంది, ఇది అంచనాలను రూపొందించడానికి లేబుళ్ళను కలిగి ఉంటుంది.

రిగ్రెషన్ మరియు వర్గీకరణ పర్యవేక్షించబడిన అభ్యాసానికి కొన్ని ఉదాహరణలు.

# వర్గీకరణ:

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

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

# పురోగతి:

రిగ్రెషన్ అనేది పర్యవేక్షించబడే అభ్యాస అల్గోరిథం, ఇది ఒక వేరియబుల్ మరొక వేరియబుల్‌ను ఎలా ప్రభావితం చేస్తుందో నిర్ణయించడంలో సహాయపడుతుంది.

ఇక్కడ, “లివింగ్_ఆరియా” అనేది స్వతంత్ర వేరియబుల్ మరియు “ధర” అనేది డిపెండెంట్ వేరియబుల్, అనగా “లివింగ్_అరియా” కి సంబంధించి “ధర” ఎలా మారుతుందో మేము నిర్ణయిస్తున్నాము.

• పర్యవేక్షించబడని అభ్యాసం:

పర్యవేక్షించబడని అభ్యాస అల్గోరిథం లేబుల్స్ లేని డేటా నుండి అనుమానాలను ఆకర్షిస్తుంది.

క్లస్టరింగ్ పర్యవేక్షించబడని అభ్యాసానికి ఉదాహరణ. “K- అంటే”, “క్రమానుగత”, “మసక సి-మీన్స్” క్లస్టరింగ్ అల్గోరిథంలకు కొన్ని ఉదాహరణలు.

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

• ఉపబల అభ్యాసం:

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

తీసుకుందాం ప్యాక్మాన్ ఉదాహరణకి. ప్యాక్మాన్ ఆహారాన్ని తినడం కొనసాగిస్తున్నంత కాలం, అది పాయింట్లను సంపాదిస్తుంది, కానీ అది ఒక రాక్షసుడిపై క్రాష్ అయినప్పుడు అది జీవితాన్ని కోల్పోతుంది. అందువల్ల ప్యాక్మాన్ ఎక్కువ ఆహారాన్ని తినాలని మరియు రాక్షసులను నివారించాల్సిన అవసరం ఉందని తెలుసుకుంటాడుదాని పనితీరును మెరుగుపరచడానికి.

R తో యంత్ర అభ్యాసాన్ని అమలు చేయడం:

లీనియర్ రిగ్రెషన్:

లీనియర్ రిగ్రెషన్ అల్గారిథమ్‌ను అమలు చేయడానికి మేము డైమండ్స్ డేటా-సెట్‌తో కలిసి పని చేస్తాము:

డేటా-సెట్ యొక్క వివరణ:

డేటాపై ఏదైనా మోడల్‌ను రూపొందించడానికి ముందు, మేము డేటాను “రైలు” మరియు “పరీక్ష” సెట్లుగా విభజించాల్సి ఉంటుంది. మోడల్ “రైలు” సెట్‌లో నిర్మించబడుతుంది మరియు దాని యొక్క ఖచ్చితత్వం “పరీక్ష” సెట్‌లో తనిఖీ చేయబడుతుంది.

డేటాను రెండు సెట్లుగా విభజించడానికి “caTools” ప్యాకేజీని లోడ్ చేయాలి.

లైబ్రరీ (caTools)

“CaTools” ప్యాకేజీ డేటాను విభజించడంలో సహాయపడే “sample.split ()” ఫంక్షన్‌ను అందిస్తుంది.

sample.split (వజ్రాలు $ ధర, SplitRatio = 0.65) -> split_index

ధర కాలమ్ నుండి 65% పరిశీలనలు 'నిజమైన' లేబుల్ మరియు మిగిలిన 35% 'తప్పుడు' లేబుల్ కేటాయించబడ్డాయి.

ఉపసమితి (వజ్రాలు, స్ప్లిట్_ఇండెక్స్ == టి) -> రైలు ఉపసమితి (వజ్రాలు, స్ప్లిట్_ఇండెక్స్ == ఎఫ్) -> పరీక్ష

“నిజమైన” లేబుల్ ఉన్న అన్ని పరిశీలనలు “ రైలు ”వస్తువు మరియు 'తప్పుడు' లేబుల్ ఉన్న పరిశీలనలు 'పరీక్ష' సెట్‌కు కేటాయించబడ్డాయి.

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

జావాలో ఏమి జోడించబడుతుంది

“రైలు” డేటాలో లీనియర్ రిగ్రెషన్ మోడల్‌ను రూపొందించడానికి మేము “lm ()” ఫంక్షన్‌ను ఉపయోగిస్తాము. మేము నిర్ణయిస్తున్నాము ధర డేటా-సెట్ యొక్క అన్ని ఇతర వేరియబుల్స్కు సంబంధించి వజ్రాల. నిర్మించిన మోడల్ “mod_regress” అనే వస్తువులో నిల్వ చేయబడుతుంది.

lm (ధర ~., డేటా = రైలు) -> mod_regress

ఇప్పుడు, మేము మోడల్‌ను నిర్మించాము, “పరీక్ష” సెట్‌లో అంచనాలు వేయాలి. అంచనాలను పొందడానికి “ప్రిడిక్ట్ ()” ఫంక్షన్ ఉపయోగించబడుతుంది. ఇది రెండు వాదనలు తీసుకుంటుంది: ది నిర్మించిన మోడల్ ఇంకా పరీక్ష సెట్. Results హించిన ఫలితాలు “result_regress” ఆబ్జెక్ట్‌లో నిల్వ చేయబడతాయి.

ict హించండి (mod_regress, test) -> result_regress

“పరీక్ష” డేటా-సెట్ మరియు values ​​హించిన విలువల నుండి వాస్తవ ధర విలువలను “సిబిండ్ ()” ఫంక్షన్‌ను ఉపయోగించి ఒకే డేటా-సెట్‌లోకి బంధిద్దాం. క్రొత్త డేటా-ఫ్రేమ్ “ఫైనల్_డేటా” లో నిల్వ చేయబడుతుంది

cbind (అసలైన = పరీక్ష $ ధర, icted హించినది = ఫలితం_ప్రగతి) -> తుది_డేటా 

as.data.frame (ఫైనల్_డేటా) -> ఫైనల్_డేటా

వాస్తవ విలువలు మరియు values ​​హించిన విలువలను కలిగి ఉన్న “ఫైనల్_డేటా” వద్ద ఒక చూపు:

Values ​​హించిన విలువలను వాస్తవ విలువల నుండి తీసివేయడం ద్వారా లోపాన్ని కనుగొని, ఈ లోపాన్ని “ఫైనల్_డేటా” కి కొత్త కాలమ్‌గా జోడించండి:

(ఫైనల్_డేటా $ అసలైన- ఫైనల్_డేటా red icted హించబడింది) -> లోపం

cbind (ఫైనల్_డేటా, లోపం) -> ఫైనల్_డేటా

“ఫైనల్_డేటా” వద్ద ఒక చూపు, ఇది అంచనాలోని లోపాన్ని కూడా కలిగి ఉంటుంది:

ఇప్పుడు, మేము ముందుకు వెళ్లి లెక్కిస్తాము “ రూట్ మీన్ స్క్వేర్ లోపం ” ఇది అన్ని అంచనాలకు మొత్తం లోపం ఇస్తుంది

rmse1<-sqrt(mean(Final_Data$error^2)) 

rmse1

ముందుకు వెళుతున్నప్పుడు, మరొక మోడల్‌ను నిర్మిద్దాం, తద్వారా ఈ రెండు మోడళ్ల యొక్క ఖచ్చితత్వాన్ని పోల్చవచ్చు మరియు ఏది మంచిదో నిర్ణయించవచ్చు.

మేము “రైలు” సెట్‌లో కొత్త లీనియర్ రిగ్రెషన్ మోడల్‌ను నిర్మిస్తాము, కాని ఈ సమయంలో, మేము స్వతంత్ర చరరాశుల నుండి 'x' మరియు 'y' నిలువు వరుసలను వదులుతాము, అంటే వజ్రాల “ధర” అన్నీ నిర్ణయించబడతాయి 'x' మరియు 'y' మినహా నిలువు వరుసలు.

నిర్మించిన మోడల్ “mod_regress2” లో నిల్వ చేయబడింది:

lm (ధర ~.-y-z, డేటా = రైలు) -> mod_regress2

Results హించిన ఫలితాలు “result_regress2” లో నిల్వ చేయబడతాయి

ict హించండి (mod_regress2, test) -> result_regress2

వాస్తవ మరియు అంచనా విలువలు కలిపి “ఫైనల్_డేటా 2” లో నిల్వ చేయబడతాయి:

cbind (అసలైన = పరీక్ష $ ధర, icted హించిన = ఫలితం_రెగ్రెస్ 2) -> ఫైనల్_డేటా 2 

as.data.frame (ఫైనల్_డేటా 2) -> ఫైనల్_డేటా 2

“ఫైనల్_డేటా 2” కు in హించే లోపాన్ని కూడా చేర్చుదాం

(ఫైనల్_డేటా 2 $ అసలైన- ఫైనల్_డేటా 2 red icted హించబడింది) -> లోపం 2

cbind (ఫైనల్_డేటా 2, ఎర్రర్ 2) -> ఫైనల్_డేటా 2

“ఫైనల్_డేటా 2” వద్ద ఒక చూపు:

మొత్తం లోపం పొందడానికి రూట్ మీన్ స్క్వేర్ లోపం కనుగొనడం:

rmse2<-sqrt(mean(Final_Data2$error^2))

“Rmse2” “rmse1” కన్నా స్వల్పంగా తక్కువగా ఉందని మేము చూశాము, అందువల్ల రెండవ మోడల్ మొదటి మోడల్ కంటే కొంచెం మెరుగ్గా ఉంది.

వర్గీకరణ:

మేము అమలు చేయడానికి “కార్_ కొనుగోలు” డేటా-సెట్‌తో పని చేస్తాము పునరావృత విభజన ఇది వర్గీకరణ అల్గోరిథం.

“CaTools” ప్యాకేజీ నుండి “sample.split ()” ఫంక్షన్‌ను ఉపయోగించి డేటాను “రైలు” మరియు “పరీక్ష” సెట్లుగా విభజిద్దాం.

లైబ్రరీ (caTools)

‘కొనుగోలు చేసిన’ కాలమ్ నుండి 65% పరిశీలనలు “TRUE” లేబుల్‌లకు కేటాయించబడతాయి మరియు మిగిలినవి “FALSE” లేబుల్‌లకు కేటాయించబడతాయి.

sample.split (car_purchase $ కొనుగోలు చేయబడింది, SplitRatio = 0.65) -> split_values

“TRUE” లేబుల్ ఉన్న అన్ని పరిశీలనలు ‘రైలు’ డేటాలో నిల్వ చేయబడతాయి మరియు “FALSE” లేబుల్ ఉన్న పరిశీలనలు ‘పరీక్ష’ డేటాకు కేటాయించబడతాయి.

ఉపసమితి (కార్_ కొనుగోలు, స్ప్లిట్_వాల్యూస్ == టి) -> రైలు_డేటా

ఉపసమితి (కార్_ కొనుగోలు, స్ప్లిట్_వాల్యూస్ == ఎఫ్) -> టెస్ట్_డేటా

పునరావృత విభజన అల్గోరిథం నిర్మించడానికి సమయం:

మేము ‘rpart’ ప్యాకేజీని లోడ్ చేయడం ద్వారా ప్రారంభిస్తాము:

లైబ్రరీ (rpart)

“కొనుగోలు చేసిన” కాలమ్ డిపెండెంట్ వేరియబుల్ అవుతుంది మరియు అన్ని ఇతర నిలువు వరుసలు స్వతంత్ర వేరియబుల్స్, అనగా వ్యక్తి కారు కొన్నారా లేదా అన్ని ఇతర నిలువు వరుసలకు సంబంధించి కాదా అని మేము నిర్ణయిస్తున్నాము. మోడల్ “రైలు_డేటా” పై నిర్మించబడింది మరియు ఫలితం “మోడ్ 1” లో నిల్వ చేయబడుతుంది.

rpart (కొనుగోలు ~., డేటా = రైలు_డేటా) -> mod1

ఫలితాన్ని ప్లాట్ చేద్దాం:

ప్లాట్ (mod1, మార్జిన్ = 0.1) టెక్స్ట్ (mod1, అందంగా = T, cex = 0.8)

ఇప్పుడు, “test_data” లో ఫలితాలను అంచనా వేద్దాం. మేము నిర్మించిన rpart మోడల్ “mod1” ను మొదటి వాదనగా, పరీక్ష సెట్ “test_data” ను రెండవ ఆర్గ్యుమెంట్‌గా మరియు ప్రిడిక్షన్ రకాన్ని మూడవ ఆర్గ్యుమెంట్‌కు “క్లాస్” గా ఇస్తున్నాము. ఫలితం ‘result1’ ఆబ్జెక్ట్‌లో నిల్వ చేయబడుతుంది.

ict హించండి (mod1, test_data, type = 'class') -> result1

కేరెట్ ప్యాకేజీ నుండి “కన్‌ఫ్యూజన్ మ్యాట్రిక్స్ ()” ఫంక్షన్‌ను ఉపయోగించి మోడల్ యొక్క ఖచ్చితత్వాన్ని అంచనా వేద్దాం.

లైబ్రరీ (కేరెట్) confusionMatrix (పట్టిక (test_data $ కొనుగోలు, ఫలితం 1))

గందరగోళ మాతృక మనకు చెబుతుంది, ఆ వ్యక్తి కారును కొనుగోలు చేయని 90 పరిశీలనలలో, 79 పరిశీలనలు సరిగ్గా “లేదు” అని వర్గీకరించబడ్డాయి మరియు 11 తప్పుగా “అవును” అని వర్గీకరించబడ్డాయి. అదేవిధంగా, వ్యక్తి వాస్తవానికి కారును కొనుగోలు చేసిన 50 పరిశీలనలలో 47 మందిని “అవును” అని వర్గీకరించారు మరియు 3 తప్పుగా “NO” గా వర్గీకరించబడ్డాయి.

సరైన అంచనాలను మొత్తం అంచనాలతో విభజించడం ద్వారా మేము మోడల్ యొక్క ఖచ్చితత్వాన్ని కనుగొనవచ్చు, అనగా (79 + 47) / (79 + 47 + 11 + 3).

K- మీన్స్ క్లస్టరింగ్:

K- అంటే క్లస్టరింగ్‌ను అమలు చేయడానికి మేము “ఐరిస్” డేటా-సెట్‌తో పని చేస్తాము:

“జాతుల” కాలమ్‌ను తీసివేసి, ‘ఐరిస్’ డేటా-సెట్ నుండి మొదటి నాలుగు నిలువు వరుసలను మాత్రమే కలిగి ఉన్న క్రొత్త డేటా-సెట్‌ను సృష్టించండి.

iris [1: 4] -> iris_k

క్లస్టర్ల సంఖ్యను 3 గా తీసుకుందాం. “Kmeans ()” ఫంక్షన్ ఇన్పుట్ డేటాను మరియు డేటాను క్లస్టర్ చేయవలసిన క్లస్టర్ల సంఖ్యను తీసుకుంటుంది. వాక్యనిర్మాణం: kmeans (డేటా, k) ఇక్కడ k అనేది క్లస్టర్ కేంద్రాల సంఖ్య.

kmeans (iris_k, 3) -> k1

క్లస్టరింగ్‌ను విశ్లేషించడం:

str (k1)

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

betweenss: చతురస్రాల మొత్తం మధ్య, అంటే ఇంట్రాక్లస్టర్ సారూప్యత

లోపల: చదరపు మొత్తంలో అనగా ఇంటర్‌క్లస్టర్ సారూప్యత

SQL సర్వర్ ఉదాహరణలో సబ్‌స్ట్రింగ్

totwithinss: అన్ని సమూహాల లోపలి మొత్తం మొత్తం, అంటే మొత్తం ఇంట్రా-క్లస్టర్ సారూప్యత

మంచి క్లస్టరింగ్‌లో “tot.withinss” యొక్క తక్కువ విలువ మరియు “betweenss” యొక్క అధిక విలువ ఉంటుంది, ఇది ప్రారంభంలో ఎంచుకున్న ‘k’ క్లస్టర్‌ల సంఖ్యపై ఆధారపడి ఉంటుంది.

మీ మార్గంలోకి వచ్చే కొత్త అవకాశాలను సద్వినియోగం చేసుకోవడానికి మెషిన్ లెర్నింగ్‌లో నిపుణుడిగా మారడానికి సమయం పండింది. ఇది మమ్మల్ని ఈ ముగింపుకు తీసుకువస్తుంది “ R తో యంత్ర అభ్యాసం ”బ్లాగ్. ఈ బ్లాగ్ సమాచార ఫలవంతమైనదని నేను నమ్ముతున్నాను.

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