ప్రతి AI వ్యవస్థకు డేటాను వేగంగా నిల్వ చేయడం మరియు తిరిగి పొందడం అవసరం. అది ఒక చిత్రంలోని పిక్సెల్ విలువల జాబితా అయినా, 50,000 పదాల పదకోశం అయినా, లేదా లక్షలాది వినియోగదారుల అభిరుచులు అయినా - డేటా నిర్మాణం ఎంపిక మీ AI ఎంత వేగంగా ఆలోచించగలదో నిర్ణయిస్తుంది.
రెండు నిర్మాణాలు ప్రాధాన్యత వహిస్తాయి: అర్రేలు మరియు హాష్ మ్యాప్లు. వీటిని నేర్చుకుంటే, దాదాపు ప్రతి AI పైప్లైన్ కి పునాది ఏర్పడుతుంది.
అర్రే అనేది మెమరీలో పక్కపక్కనే నిల్వ చేయబడిన అంశాల సంఖ్యాంక జాబితా. ప్రతి అంశానికి ఒక ఇండెక్స్ ఉంటుంది - జాబితాలో దాని స్థానం, సున్నా నుండి మొదలవుతుంది.
index: 0 1 2 3 4
value: ["cat", "dog", "bird", "fish", "frog"]
అంశాలు పక్కపక్కనే ఉన్నందున, మీరు ఏ స్థానానికైనా నేరుగా వెళ్ళవచ్చు. 3వ అంశం కావాలా? అయిపోయింది - వెతకడం అవసరం లేదు. ఇది O(1) ప్రాప్యత, అంటే అర్రే లో 10 లేదా 10 మిలియన్ అంశాలు ఉన్నా ఒకే సమయం పడుతుంది.
మధ్యలో చేర్చడం లేదా తొలగించడం ఖరీదైనది. మార్పు తర్వాత ప్రతి అంశం జరగాలి. ఇది O(n) - ఎక్కువ అంశాలు ఉంటే, ఎక్కువ సమయం పడుతుంది.
మీ దగ్గర 10,000 పాటల ప్లేలిస్ట్ ఉంటే, 5వ స్థానంలో కొత్త పాట చేర్చాలనుకుంటే, 5వ స్థానం నుండి ప్రతి పాట జరగాలి. ఒక స్ట్రీమింగ్ సేవ నెమ్మదించకుండా దీన్ని ఎలా నిర్వహించవచ్చు?
హాష్ మ్యాప్ (నిఘంటువు లేదా హాష్ టేబుల్ అని కూడా పిలుస్తారు) డేటాను కీలక-విలువ జతలు గా నిల్వ చేస్తుంది. ఇండెక్స్ సంఖ్య ద్వారా కాకుండా, అర్థవంతమైన కీలక ద్వారా అంశాలను ప్రాప్తి చేస్తారు.
word_counts = {
"hello": 42,
"world": 37,
"AI": 156
}
సైన్ ఇన్ చేయండి చర్చలో పాల్గొనడానికి
"AI" కోసం సంఖ్య కావాలా? హాష్ మ్యాప్ ఒక హాష్ ఫంక్షన్ ను ఉపయోగించి కీలక ని అంతర్గతంగా ఇండెక్స్ గా మారుస్తుంది. ఫలితం? సగటున O(1) లుకప్ సమయం - అర్రేలు లాగే, కానీ సంఖ్యలకు బదులు పేర్లు ఉపయోగిస్తారు.
Python నిఘంటువులు అనేవి హాష్ మ్యాప్లు. ChatGPT శిక్షణ సమయంలో పద ఫ్రీక్వెన్సీలను లెక్కించేటప్పుడు, ఇంటర్నెట్ మొత్తం పాఠ్యం అంతటా బిలియన్ల పద సంఘటనలను ట్రాక్ చేయడానికి హాష్-మ్యాప్ లాంటి నిర్మాణాలను ఉపయోగిస్తుంది.
| కార్యకలాపం | అర్రే | హాష్ మ్యాప్ | |-----------|-------|----------| | ఇండెక్స్ ద్వారా ప్రాప్యత | O(1) ⚡ | N/A | | కీలక ద్వారా ప్రాప్యత | O(n) 🐢 | O(1) ⚡ | | చివర చేర్చడం | O(1) ⚡ | O(1) ⚡ | | మధ్యలో చేర్చడం | O(n) 🐢 | N/A | | విలువ కోసం వెతకడం | O(n) 🐢 | O(1) ⚡ |
O(1) అంటే "పరిమాణంతో సంబంధం లేకుండా తక్షణం" మరియు O(n) అంటే "డేటా పెద్దదైతే నెమ్మదిగా" అని భావించండి.
మీ దగ్గర 100,000 వినియోగదారు ప్రొఫైల్లు ఉన్నాయి, వినియోగదారు పేరు ద్వారా వినియోగదారుని కనుగొనాలి. ఏ నిర్మాణం వేగవంతమైనది?
ఇంటర్వ్యూలు మరియు AI రెండింటిలోనూ అత్యంత ఉపయోగకరమైన పాటర్న్లలో ఒకటి సంఘటనలను లెక్కించడం. ఆలోచన సూడోకోడ్ లో:
counts = {}
for each word in text:
if word in counts:
counts[word] = counts[word] + 1
else:
counts[word] = 1
పాఠ్యం ద్వారా ఒకే సారి చదవడం ప్రతి పదం యొక్క ఫ్రీక్వెన్సీని ఇస్తుంది. భాషా నమూనాలు ఏ పదాలు అత్యంత ముఖ్యమైనవో అర్థం చేసుకోవడానికి సరిగ్గా ఈ విధానాన్నే (భారీ స్థాయిలో) ఉపయోగిస్తాయి.
సంఖ్యల అర్రే మరియు లక్ష్య విలువ ఇచ్చినప్పుడు, లక్ష్యానికి సమానమయ్యే రెండు సంఖ్యలను కనుగొనండి. సాధారణ విధానం ప్రతి జతను తనిఖీ చేస్తుంది - O(n²). తెలివైన విధానం హాష్ మ్యాప్ ఉపయోగిస్తుంది:
seen = {}
for each number in array:
complement = target - number
if complement in seen:
return [seen[complement], current_index]
seen[number] = current_index
ఒకే సారి, O(n) సమయం. హాష్ మ్యాప్ మీరు ఇప్పటికే చూసిన దాన్ని గుర్తుంచుకుంటుంది.
రెండు-మొత్తం కోసం హాష్ మ్యాప్ విధానం ప్రతి జతను తనిఖీ చేయడం కంటే వేగవంతమైనది ఎందుకు?
ఒక సిఫార్సు ఇంజిన్ వినియోగదారుకు సినిమా సూచించే ముందు ఆ సినిమా ఇప్పటికే చూశారా అని తనిఖీ చేయాలి. వినియోగదారు చూసిన చరిత్రను అర్రే లో నిల్వ చేస్తారా లేదా హాష్ మ్యాప్ లో? ఏ రాజీలు గుర్తుకు వస్తాయి?
ఒక AI మోడల్ పదం ఎంబెడ్డింగ్లు ను ఒక్కొక్కటి 300 సంఖ్యల అర్రేలు గా నిల్వ చేస్తుంది. అర్రేలు ఇక్కడ మంచి ఎంపిక ఎందుకు?
AI డేటాను నిర్వహించడంలో అత్యంత ముఖ్యమైన రెండు నిర్మాణాలు ఇప్పుడు మీకు తెలుసు. తర్వాతి పాఠం స్ట్రింగ్లు మరియు పాఠ్య ప్రాసెసింగ్లో, AI ముడి వచనాన్ని మోడల్ నిజంగా చదవగలిగే రూపంలోకి ఎలా మారుస్తుందో చూద్దాం. మీరు వాడే ప్రతి చాట్బాట్, ప్రతి సెర్చ్ బాక్స్ వెనుక ఉండే మొదటి అడుగు ఇదే.