ప్రతి AI వ్యవస్థకు డేటాను వేగంగా నిల్వ చేయడం మరియు తిరిగి పొందడం అవసరం. అది ఒక చిత్రంలోని pixel విలువల జాబితా అయినా, 50,000 పదాల vocabulary అయినా, లేదా లక్షలాది వినియోగదారుల అభిరుచులు అయినా - data structure ఎంపిక మీ AI ఎంత వేగంగా ఆలోచించగలదో నిర్ణయిస్తుంది.
రెండు నిర్మాణాలు ప్రాధాన్యత వహిస్తాయి: arrays మరియు hash maps. వీటిని నేర్చుకుంటే, దాదాపు ప్రతి AI pipeline కి పునాది ఏర్పడుతుంది.
Array అనేది మెమరీలో పక్కపక్కనే నిల్వ చేయబడిన అంశాల సంఖ్యాంక జాబితా. ప్రతి అంశానికి ఒక index ఉంటుంది - జాబితాలో దాని స్థానం, సున్నా నుండి మొదలవుతుంది.
index: 0 1 2 3 4
value: ["cat", "dog", "bird", "fish", "frog"]
అంశాలు పక్కపక్కనే ఉన్నందున, మీరు ఏ స్థానానికైనా నేరుగా వెళ్ళవచ్చు. 3వ అంశం కావాలా? అయిపోయింది - వెతకడం అవసరం లేదు. ఇది O(1) ప్రాప్యత, అంటే array లో 10 లేదా 10 మిలియన్ అంశాలు ఉన్నా ఒకే సమయం పడుతుంది.
మధ్యలో చేర్చడం లేదా తొలగించడం ఖరీదైనది. మార్పు తర్వాత ప్రతి అంశం జరగాలి. ఇది O(n) - ఎక్కువ అంశాలు ఉంటే, ఎక్కువ సమయం పడుతుంది.
మీ దగ్గర 10,000 పాటల playlist ఉంటే, 5వ స్థానంలో కొత్త పాట చేర్చాలనుకుంటే, 5వ స్థానం నుండి ప్రతి పాట జరగాలి. ఒక streaming సేవ నెమ్మదించకుండా దీన్ని ఎలా నిర్వహించవచ్చు?
Hash map (dictionary లేదా hash table అని కూడా పిలుస్తారు) డేటాను key-value జతలు గా నిల్వ చేస్తుంది. Index సంఖ్య ద్వారా కాకుండా, అర్థవంతమైన key ద్వారా అంశాలను ప్రాప్తి చేస్తారు.
word_counts = {
"hello": 42,
"world": 37,
"AI": 156
}
Sign in to join the discussion
"AI" కోసం సంఖ్య కావాలా? Hash map ఒక hash function ను ఉపయోగించి key ని అంతర్గతంగా index గా మారుస్తుంది. ఫలితం? సగటున O(1) lookup సమయం - arrays లాగే, కానీ సంఖ్యలకు బదులు పేర్లు ఉపయోగిస్తారు.
Python dictionaries అనేవి hash maps. ChatGPT training సమయంలో పద ఫ్రీక్వెన్సీలను లెక్కించేటప్పుడు, ఇంటర్నెట్ మొత్తం టెక్స్ట్ అంతటా బిలియన్ల పద సంఘటనలను ట్రాక్ చేయడానికి hash-map లాంటి నిర్మాణాలను ఉపయోగిస్తుంది.
| కార్యకలాపం | Array | Hash Map | |-----------|-------|----------| | Index ద్వారా ప్రాప్యత | O(1) ⚡ | N/A | | Key ద్వారా ప్రాప్యత | O(n) 🐢 | O(1) ⚡ | | చివర చేర్చడం | O(1) ⚡ | O(1) ⚡ | | మధ్యలో చేర్చడం | O(n) 🐢 | N/A | | విలువ కోసం వెతకడం | O(n) 🐢 | O(1) ⚡ |
O(1) అంటే "పరిమాణంతో సంబంధం లేకుండా తక్షణం" మరియు O(n) అంటే "డేటా పెద్దదైతే నెమ్మదిగా" అని భావించండి.
మీ దగ్గర 100,000 వినియోగదారు ప్రొఫైల్లు ఉన్నాయి, username ద్వారా వినియోగదారుని కనుగొనాలి. ఏ నిర్మాణం వేగవంతమైనది?
ఇంటర్వ్యూలు మరియు AI రెండింటిలోనూ అత్యంత ఉపయోగకరమైన పాటర్న్లలో ఒకటి సంఘటనలను లెక్కించడం. ఆలోచన pseudocode లో:
counts = {}
for each word in text:
if word in counts:
counts[word] = counts[word] + 1
else:
counts[word] = 1
టెక్స్ట్ ద్వారా ఒకే సారి చదవడం ప్రతి పదం యొక్క ఫ్రీక్వెన్సీని ఇస్తుంది. భాషా నమూనాలు ఏ పదాలు అత్యంత ముఖ్యమైనవో అర్థం చేసుకోవడానికి సరిగ్గా ఈ విధానాన్నే (భారీ స్థాయిలో) ఉపయోగిస్తాయి.
సంఖ్యల array మరియు లక్ష్య విలువ ఇచ్చినప్పుడు, లక్ష్యానికి సమానమయ్యే రెండు సంఖ్యలను కనుగొనండి. సాధారణ విధానం ప్రతి జతను తనిఖీ చేస్తుంది - O(n²). తెలివైన విధానం hash map ఉపయోగిస్తుంది:
seen = {}
for each number in array:
complement = target - number
if complement in seen:
return [seen[complement], current_index]
seen[number] = current_index
ఒకే సారి, O(n) సమయం. Hash map మీరు ఇప్పటికే చూసిన దాన్ని గుర్తుంచుకుంటుంది.
Two-sum కోసం hash map విధానం ప్రతి జతను తనిఖీ చేయడం కంటే వేగవంతమైనది ఎందుకు?
ఒక recommendation engine వినియోగదారుకు సినిమా సూచించే ముందు ఆ సినిమా ఇప్పటికే చూశారా అని తనిఖీ చేయాలి. వినియోగదారు చూసిన చరిత్రను array లో నిల్వ చేస్తారా లేదా hash map లో? ఏ trade-offs గుర్తుకు వస్తాయి?
ఒక AI మోడల్ word embeddings ను ఒక్కొక్కటి 300 సంఖ్యల arrays గా నిల్వ చేస్తుంది. Arrays ఇక్కడ మంచి ఎంపిక ఎందుకు?