AIUnlimited
🌳

AI పునాదులు

🌱
AI Seeds

సున్నా నుండి ప్రారంభించండి

🌿
AI Sprouts

పునాదులు నిర్మించండి

🌳
AI Branches

ఆచరణలో అన్వయించండి

🏕️
AI Canopy

లోతుగా వెళ్ళండి

🌲
AI Forest

AI లో నిపుణత సాధించండి

🔨

AI నైపుణ్యం

✏️
AI Sketch

సున్నా నుండి ప్రారంభించండి

🪨
AI Chisel

పునాదులు నిర్మించండి

⚒️
AI Craft

ఆచరణలో అన్వయించండి

💎
AI Polish

లోతుగా వెళ్ళండి

🏆
AI Masterpiece

AI లో నిపుణత సాధించండి

📘

AI ఆచరణ

📖
ఓపెన్-సోర్స్ మోడల్స్ అర్థం చేసుకోవడం

ఓపెన్-సోర్స్ మోడల్స్ ప్రాథమికాలు మరియు వనరులు

🎯
సమస్య నుండి మోడల్ టాస్క్‌కు

వ్యాపార సమస్యలను మోడల్ టాస్క్‌లుగా మార్చడం

⚡
మీ మొదటి మోడల్ నడపడం

30 నిమిషాల్లో మీ మొదటి ఫలితాలను చూడండి

🔧
ఫైన్-ట్యూనింగ్ మరియు మూల్యాంకనం

మోడల్స్ ఫైన్-ట్యూన్ చేసి పనితీరును మూల్యాంకనం చేయండి

🚀
అప్లికేషన్ సిస్టమ్‌లు

వాస్తవ AI అనువర్తనాలను నిర్మించండి

🎨
జనరేటివ్ AI

ఓపెన్-సోర్స్ AIGC మోడల్స్ అన్వేషించండి

🤖
ఏజెంట్లు

ఏజెంట్ ఫ్రేమ్‌వర్క్‌లు మరియు MCP టూల్స్ నేర్చుకోండి

📐
సప్లిమెంటరీ ప్రాథమికాలు

LLM ప్రాథమికాలు మరియు మూల్యాంకనం

🎓

Claude Academy

🤖
Claude 101

Learn AI basics with Claude

💻
Claude Code 101

Code with Claude as your pair programmer

🤝
Introduction to Claude Cowork

Collaborate with Claude on complex projects

⚙️
Claude Platform 101

Build apps with the Claude API

ల్యాబ్

7 ప్రయోగాలు లోడ్ అయ్యాయి
🧬Neural Network Playground🤖AI లేదా మనిషి?🥋Prompt Engineering Dojo🏁Algorithm Race🧠AI ట్రివియా ఛాలెంజ్🏗️సిస్టమ్ డిజైన్ క్యాన్వాస్
🎯మాక్ ఇంటర్వ్యూల్యాబ్‌లోకి వెళ్ళండి→
🚀

కెరీర్ అభివృద్ధి

🚀
ఇంటర్వ్యూ లాంచ్‌ప్యాడ్

మీ ప్రయాణం ప్రారంభించండి

🌟
ప్రవర్తనా ఇంటర్వ్యూ నైపుణ్యం

సాఫ్ట్ స్కిల్స్ నేర్చుకోండి

💻
సాంకేతిక ఇంటర్వ్యూలు

కోడింగ్ రౌండ్ విజయం సాధించండి

🤖
AI & ML ఇంటర్వ్యూలు

ML ఇంటర్వ్యూ నైపుణ్యం

🏆
ఆఫర్ & అంతకు మించి

అత్యుత్తమ ఆఫర్ పొందండి

నేర్చుకోవడం ప్రారంభించండి
AIUnlimited

MIT లైసెన్స్

沪ICP备18025655号-11

నేర్చుకోండి

  • AI ప్రాథమికాలు
  • AI ఆచరణ
  • Claude Academy
  • ల్యాబ్
  • కెరీర్ అభివృద్ధి

సంఘం

  • మా గురించి
  • తరచుగా అడిగే ప్రశ్నలు

మద్దతు

  • footer.terms
  • footer.privacy
  • footer.contact
AI & ఇంజనీరింగ్ ప్రోగ్రామ్‌లు›✏️ AI Sketch›పాఠాలు›Arrays మరియు Hash Maps
📦
AI Sketch • మధ్యస్థం⏱️ 15 నిమిషాల పఠన సమయం

Arrays మరియు Hash Maps

AI లో డేటా నిల్వ ఎందుకు ముఖ్యం

ప్రతి AI వ్యవస్థకు డేటాను వేగంగా నిల్వ చేయడం మరియు తిరిగి పొందడం అవసరం. అది ఒక చిత్రంలోని pixel విలువల జాబితా అయినా, 50,000 పదాల vocabulary అయినా, లేదా లక్షలాది వినియోగదారుల అభిరుచులు అయినా - data structure ఎంపిక మీ AI ఎంత వేగంగా ఆలోచించగలదో నిర్ణయిస్తుంది.

రెండు నిర్మాణాలు ప్రాధాన్యత వహిస్తాయి: arrays మరియు hash maps. వీటిని నేర్చుకుంటే, దాదాపు ప్రతి AI pipeline కి పునాది ఏర్పడుతుంది.

Arrays - తక్షణ ప్రాప్యతతో క్రమబద్ధమైన జాబితాలు

Array అనేది మెమరీలో పక్కపక్కనే నిల్వ చేయబడిన అంశాల సంఖ్యాంక జాబితా. ప్రతి అంశానికి ఒక index ఉంటుంది - జాబితాలో దాని స్థానం, సున్నా నుండి మొదలవుతుంది.

index:   0       1       2       3       4
value: ["cat", "dog", "bird", "fish", "frog"]

అంశాలు పక్కపక్కనే ఉన్నందున, మీరు ఏ స్థానానికైనా నేరుగా వెళ్ళవచ్చు. 3వ అంశం కావాలా? అయిపోయింది - వెతకడం అవసరం లేదు. ఇది O(1) ప్రాప్యత, అంటే array లో 10 లేదా 10 మిలియన్ అంశాలు ఉన్నా ఒకే సమయం పడుతుంది.

0 నుండి 4 వరకు indices ఉన్న ఐదు ఎలిమెంట్ల array, index 3 కి direct access చూపిస్తూ
Arrays మీకు index ద్వారా ఏ స్థానానికైనా నేరుగా వెళ్ళడానికి అనుమతిస్తాయి.

Arrays ఎప్పుడు రాణిస్తాయి

  • Feature vectors: ఒక చిత్రాన్ని 784 సంఖ్యల array గా (28×28 pixels) సూచించవచ్చు, ప్రతిదానిలో ప్రకాశ విలువ ఉంటుంది.
  • Embeddings: భాషా నమూనాలు పదాల అర్థాలను వందలాది floating-point సంఖ్యల arrays గా నిల్వ చేస్తాయి.
  • Batch processing: GPU వేలాది ఉదాహరణలను ఏకకాలంలో ప్రాసెస్ చేయడానికి training data ను arrays లో లోడ్ చేస్తారు.

పరిమితి

మధ్యలో చేర్చడం లేదా తొలగించడం ఖరీదైనది. మార్పు తర్వాత ప్రతి అంశం జరగాలి. ఇది O(n) - ఎక్కువ అంశాలు ఉంటే, ఎక్కువ సమయం పడుతుంది.

🤔
Think about it:

మీ దగ్గర 10,000 పాటల playlist ఉంటే, 5వ స్థానంలో కొత్త పాట చేర్చాలనుకుంటే, 5వ స్థానం నుండి ప్రతి పాట జరగాలి. ఒక streaming సేవ నెమ్మదించకుండా దీన్ని ఎలా నిర్వహించవచ్చు?

Hash Maps - పేరు ద్వారా తక్షణ అన్వేషణ

Hash map (dictionary లేదా hash table అని కూడా పిలుస్తారు) డేటాను key-value జతలు గా నిల్వ చేస్తుంది. Index సంఖ్య ద్వారా కాకుండా, అర్థవంతమైన key ద్వారా అంశాలను ప్రాప్తి చేస్తారు.

word_counts = {
  "hello": 42,
  "world": 37,
  "AI": 156
}
పాఠం 1 / 100% పూర్తి
←ప్రోగ్రామ్‌కు తిరిగి

చర్చ

సైన్ ఇన్ చర్చలో చేరండి

"AI" కోసం సంఖ్య కావాలా? Hash map ఒక hash function ను ఉపయోగించి key ని అంతర్గతంగా index గా మారుస్తుంది. ఫలితం? సగటున O(1) lookup సమయం - arrays లాగే, కానీ సంఖ్యలకు బదులు పేర్లు ఉపయోగిస్తారు.

🤯

Python dictionaries అనేవి hash maps. ChatGPT training సమయంలో పద ఫ్రీక్వెన్సీలను లెక్కించేటప్పుడు, ఇంటర్నెట్ మొత్తం టెక్స్ట్ అంతటా బిలియన్ల పద సంఘటనలను ట్రాక్ చేయడానికి hash-map లాంటి నిర్మాణాలను ఉపయోగిస్తుంది.

AI లో Hash Maps యొక్క వాస్తవ ఉపయోగాలు

  • Vocabulary mapping: "brilliant" వంటి పదాలను భాషా నమూనా కోసం token ID 8921 గా మార్చడం.
  • Frequency counting: Dataset లో ప్రతి పదం ఎన్ని సార్లు కనిపిస్తుంది? Hash maps ఒకే సారి చదివి సమాధానం ఇస్తాయి.
  • ఫలితాల caching: AI ఇప్పటికే X ఇన్‌పుట్ కోసం prediction లెక్కించి ఉంటే, దాన్ని నిల్వ చేయండి - మళ్ళీ లెక్కించాల్సిన అవసరం ఉండదు.

సమయ సంక్లిష్టత సరళంగా

| కార్యకలాపం | 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 ద్వారా వినియోగదారుని కనుగొనాలి. ఏ నిర్మాణం వేగవంతమైనది?

సాధారణ పాటర్న్: Frequency Counting

ఇంటర్వ్యూలు మరియు AI రెండింటిలోనూ అత్యంత ఉపయోగకరమైన పాటర్న్‌లలో ఒకటి సంఘటనలను లెక్కించడం. ఆలోచన pseudocode లో:

counts = {}
for each word in text:
    if word in counts:
        counts[word] = counts[word] + 1
    else:
        counts[word] = 1

టెక్స్ట్ ద్వారా ఒకే సారి చదవడం ప్రతి పదం యొక్క ఫ్రీక్వెన్సీని ఇస్తుంది. భాషా నమూనాలు ఏ పదాలు అత్యంత ముఖ్యమైనవో అర్థం చేసుకోవడానికి సరిగ్గా ఈ విధానాన్నే (భారీ స్థాయిలో) ఉపయోగిస్తాయి.

సాధారణ పాటర్న్: Two-Sum సమస్య

సంఖ్యల 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 విధానం ప్రతి జతను తనిఖీ చేయడం కంటే వేగవంతమైనది ఎందుకు?

ఏది ఎప్పుడు ఎంచుకోవాలి

  • Arrays ఉపయోగించండి - క్రమం ముఖ్యమైనప్పుడు, స్థానం ద్వారా అంశాలను ప్రాప్తి చేసేటప్పుడు, లేదా అన్నింటినీ వరుసగా ప్రాసెస్ చేయాల్సినప్పుడు (చిత్రంలో pixels వంటివి).
  • Hash maps ఉపయోగించండి - key ద్వారా వేగంగా వెతకాల్సినప్పుడు, సంఘటనలు లెక్కించాల్సినప్పుడు, లేదా ఏదైనా ఉనికిని త్వరగా తనిఖీ చేయాల్సినప్పుడు.
🤔
Think about it:

ఒక recommendation engine వినియోగదారుకు సినిమా సూచించే ముందు ఆ సినిమా ఇప్పటికే చూశారా అని తనిఖీ చేయాలి. వినియోగదారు చూసిన చరిత్రను array లో నిల్వ చేస్తారా లేదా hash map లో? ఏ trade-offs గుర్తుకు వస్తాయి?

🧠త్వరిత తనిఖీ

ఒక AI మోడల్ word embeddings ను ఒక్కొక్కటి 300 సంఖ్యల arrays గా నిల్వ చేస్తుంది. Arrays ఇక్కడ మంచి ఎంపిక ఎందుకు?

ముఖ్య అంశాలు

  • Arrays index ద్వారా O(1) ప్రాప్యతను అందిస్తాయి మరియు సంఖ్యాత్మక AI (చిత్రాలు, embeddings, tensors) యొక్క వెన్నెముక.
  • Hash maps key ద్వారా O(1) ప్రాప్యతను అందిస్తాయి మరియు lookups, counting మరియు caching కు అవసరం.
  • సరైన నిర్మాణాన్ని ఎంచుకోవడం O(n²) algorithm ను O(n) గా మార్చగలదు - లక్షలాది డేటా పాయింట్లను ప్రాసెస్ చేసేటప్పుడు ఈ తేడా చాలా ముఖ్యం.
  • ఆచరణలో, చాలా AI pipelines రెండింటినీ ఉపయోగిస్తాయి: సంఖ్యాత్మక లెక్కింపులకు arrays మరియు metadata lookups కు hash maps.