कंप्यूटर को समझने के लिए, आपको पहले एक भौतिक वास्तविकता को स्वीकार करना होगा। कंप्यूटर के अंदर कोई जादू नहीं है। केवल विद्युत संकेत हैं। अधिक सटीक रूप से, केवल उच्च वोल्टेज और निम्न वोल्टेज।

आज हम जिन चिप्स का उपयोग करते हैं, उनकी आधार सामग्री सिलिकॉन है। सिलिकॉन एक अर्धचालक है। अर्धचालकों में एक भौतिक गुण होता है: उनमें विभिन्न तत्वों को मिलाकर और इलेक्ट्रोड पर वोल्टेज को नियंत्रित करके, यह नियंत्रित किया जा सकता है कि वे बिजली का संचालन करते हैं या नहीं। यह छोटी संरचना जिसे बिजली द्वारा चालू और बंद किया जा सकता है, ट्रांजिस्टर कहलाती है।

आधुनिक CPU में दसियों अरबों ट्रांजिस्टर होते हैं। TSMC की वर्तमान 3 नैनोमीटर प्रक्रिया का मतलब है कि ये ट्रांजिस्टर इतने अविश्वसनीय रूप से छोटे बनाए जाते हैं कि एक नाखून के आकार के सिलिकॉन टुकड़े पर दसियों अरब फिट हो सकते हैं।

आपको केवल ट्रांजिस्टर का एक मुख्य कार्य याद रखना है। यदि आप इसके नियंत्रण टर्मिनल पर उच्च वोल्टेज लगाते हैं, तो यह चालन करता है। यदि आप निम्न वोल्टेज लगाते हैं, तो यह बंद हो जाता है। यह सबसे निचली भौतिक वास्तविकता है। हम उच्च वोल्टेज को तार्किक 1 और निम्न वोल्टेज को तार्किक 0 के रूप में परिभाषित करते हैं। सभी कंप्यूटर विज्ञान इन दो अवस्थाओं पर निर्मित है।

ट्रांजिस्टर के साथ, हम उन्हें लॉजिक गेट्स में संयोजित कर सकते हैं।

मान लीजिए हम दो ट्रांजिस्टर को श्रृंखला में जोड़ते हैं। करंट एक छोर से दूसरे छोर तक तभी प्रवाहित हो सकता है – आउटपुट 1 देते हुए – जब दोनों नियंत्रण टर्मिनल उच्च वोल्टेज प्राप्त करें, यानी दोनों इनपुट 1 हों। यदि कोई एक 0 है, तो करंट कट जाता है और आउटपुट 0 होता है। इस भौतिक सर्किट को AND गेट कहा जाता है।

उसी तर्क से, यदि दो ट्रांजिस्टर समानांतर में जुड़े हैं, तो करंट तब तक प्रवाहित होता है – आउटपुट 1 देते हुए – जब तक कम से कम एक इनपुट 1 हो। केवल जब दोनों 0 होते हैं तो आउटपुट 0 होता है। इसे OR गेट कहा जाता है।

थोड़ी अलग कनेक्शन विधि का उपयोग करके, जहां 1 इनपुट करने पर आउटपुट 0 मिलता है और 0 इनपुट करने पर आउटपुट 1 मिलता है, हम NOT गेट बनाते हैं।

AND, OR और NOT गेट्स के साथ, भौतिक दुनिया औपचारिक रूप से गणितीय दुनिया में प्रवेश करती है। मैं यहां एक क्लासिक पाठ्यपुस्तक की अत्यधिक अनुशंसा करता हूं जिसे Code कहा जाता है, चार्ल्स पेट्ज़ोल्ड द्वारा लिखित। इस पुस्तक में कोई फालतू सामग्री नहीं है – यह टेलीग्राफ से शुरू होती है और बताती है कि लॉजिक गेट्स को कैसे जोड़ा जाए। यह भौतिक अंतर्ज्ञान की उस पहली परत को बनाने के लिए एकदम सही है। आपको इस पोस्ट को पढ़ने के बाद इसे जरूर देखना चाहिए – यह आपके होश उड़ा देगी।

अब जब हमारे पास लॉजिक गेट्स हैं, तो हम कंप्यूटर से जोड़ कैसे करवाएं?

बाइनरी में, 1 जमा 1 बराबर 10 होता है। इसका मतलब है कि वर्तमान बिट 0 हो जाता है और हम अगले स्थान पर 1 को कैरी करते हैं। यह वास्तव में दो तार्किक संक्रियाएं हैं। पहला, वर्तमान बिट निर्धारित करना: यदि दोनों इनपुट 1 हैं, तो वर्तमान बिट 0 है। यदि एक इनपुट 1 है और दूसरा 0 है, तो वर्तमान बिट 1 है। इस तर्क को हमारे द्वारा चर्चित मूल गेट्स को संयोजित करके कार्यान्वित किया जा सकता है – हम इसे XOR गेट कहते हैं। दूसरा, कैरी निर्धारित करना: केवल जब दोनों इनपुट 1 होते हैं तो हम कैरी करते हैं, जो कि AND गेट का कार्य है।

एक XOR गेट और एक AND गेट को एक साथ जोड़ें, और आपने एक एकल बाइनरी अंक के जोड़ को भौतिक रूप से कार्यान्वित कर दिया है। इसे आधा योजक कहा जाता है। कई आधे योजकों को कैस्केड में जोड़ें, कैरी सिग्नल को संभालते हुए, और आपको एक पूर्ण योजक मिलता है। यदि आप इनमें से 64 पूर्ण योजकों को जोड़ते हैं, तो आपको एक भौतिक सर्किट मिलता है जो 64-बिट बाइनरी संख्याओं को जोड़ सकता है।

जब आप a = b + c कोड की पंक्ति लिखते हैं, तो सबसे निचले स्तर पर क्या होता है कि b और c का प्रतिनिधित्व करने वाले विद्युत संकेत एक साथ दसियों हजारों ट्रांजिस्टर से बने इस योजक सर्किट में प्रवेश करते हैं। एक अत्यंत छोटी भौतिक देरी के बाद, सर्किट का दूसरा छोर परिणाम का प्रतिनिधित्व करने वाले स्थिर उच्च और निम्न वोल्टेज आउटपुट करता है।

इसे अंकगणितीय तर्क इकाई (ALU) कहा जाता है। यह कोई रहस्यमय मुख्य घटक नहीं है – यह केवल अर्धचालक लॉजिक गेट्स का एक घना जाल है, जो मनुष्यों द्वारा डिज़ाइन किए गए गणितीय नियमों के अनुसार हार्डवायर्ड है। जोड़ के अलावा, विभिन्न वायरिंग कॉन्फ़िगरेशन के माध्यम से, यह घटाव, बिट शिफ्ट और यहां तक कि गुणा भी कर सकता है।

लेकिन केवल जोड़ने में सक्षम होना बेकार है। परिणाम केवल विद्युत संकेतों का एक ढेर है – जैसे ही बिजली कटती है या इनपुट बदलता है, परिणाम गायब हो जाता है। एक कंप्यूटर को डेटा याद रखने में सक्षम होना चाहिए। यह हमें मेमोरी और रजिस्टरों तक लाता है।

विद्युत संकेतों का उपयोग करके अवस्था को कैसे याद रखा जाए? इलेक्ट्रॉनिक इंजीनियरों ने एक अत्यंत चतुर सर्किट का आविष्कार किया जिसे फ्लिप-फ्लॉप कहा जाता है। यह फीडबैक लूप वाला एक लॉजिक गेट सर्किट है। सीधे शब्दों में कहें, आउटपुट सिग्नल को वापस इनपुट में फीड किया जाता है। यह डिज़ाइन सुनिश्चित करता है कि मूल इनपुट हटा दिए जाने के बाद भी, सर्किट आंतरिक फीडबैक का उपयोग करके अपनी वर्तमान उच्च या निम्न वोल्टेज स्थिति बनाए रख सकता है।

जब आप इस फ्लिप-फ्लॉप को एक विशिष्ट राइट सिग्नल देते हैं, तो यह अपनी आंतरिक स्थिति को अपडेट करता है और इसे लॉक कर देता है। जब तक आप इसे कोई अन्य राइट सिग्नल नहीं भेजते, यह उस 0 या 1 को अनिश्चित काल तक बनाए रखेगा।

64 फ्लिप-फ्लॉप को एक पंक्ति में व्यवस्थित करें, और आप एक 64-बिट बाइनरी संख्या संग्रहीत कर सकते हैं। CPU के अंदर, ALU के ठीक बगल में, फ्लिप-फ्लॉप से बनी ये अल्ट्रा-फास्ट स्टोरेज इकाइयां रजिस्टर कहलाती हैं। उनका भौतिक स्थान गणना सर्किटरी के ठीक बगल में होता है, जिसका अर्थ है कि विद्युत संकेत सबसे छोटी संभव दूरी तय करता है, इसलिए वे अत्यंत तेज़ होते हैं। बेशक, वे निर्माण में अत्यंत महंगे भी होते हैं, इसलिए वे केवल बहुत छोटे ही हो सकते हैं।

यहां मुझे एक बिल्कुल महान पुस्तक की जोरदार अनुशंसा करनी है: Computer Systems: A Programmer’s Perspective, जिसे IT दुनिया में CSAPP के नाम से जाना जाता है। यह कार्नेगी मेलन विश्वविद्यालय में उपयोग की जाने वाली पाठ्यपुस्तक है। इसे अविश्वसनीय बनाने वाली बात यह है कि यह असेंबली भाषा से हार्डवेयर आर्किटेक्चर से ऑपरेटिंग सिस्टम तक की खाई को पाटती है। इसे समझने के बाद, आपको पता चल जाएगा कि कुछ कोड तेज़ और कुछ धीमा क्यों चलता है – क्योंकि आप भौतिक स्तर की मानसिकता के साथ कोड लिखना शुरू कर देंगे।

यदि आप आगे जाना चाहते हैं और ऑपरेटिंग सिस्टम, कंप्यूटर संगठन, नेटवर्किंग और अन्य कठोर मूलभूत चीजों को एक साथ व्यवस्थित रूप से समझना चाहते हैं, तो मैंने डेटा संरचनाओं और एल्गोरिदम, कंप्यूटर संगठन और अधिक को कवर करने वाला एक संग्रह तैयार किया है।

पूरे वेब पर 1 मिलियन से अधिक डाउनलोड – कंप्यूटर की बुनियादी बातें जो आपके कौशल को बढ़ावा देंगी।

चलिए बाहर की ओर बढ़ते रहें। क्या होगा यदि रजिस्टर पर्याप्त नहीं हैं? हमें बड़े भंडारण की आवश्यकता है। यहां आपके मदरबोर्ड में लगी RAM स्टिक्स आती हैं। तकनीकी नाम डायनेमिक रैंडम एक्सेस मेमोरी, या DRAM है।

DRAM का भौतिक सिद्धांत रजिस्टरों से पूरी तरह अलग है। फ्लिप-फ्लॉप के बजाय, यह विद्युत आवेश को संग्रहीत करने के लिए सूक्ष्म संधारित्रों का उपयोग करता है। आवेश वाला संधारित्र 1 है, बिना आवेश वाला 0 है। चूंकि संधारित्र की संरचना अत्यंत सरल है – एक बिट डेटा संग्रहीत करने के लिए केवल एक ट्रांजिस्टर और एक संधारित्र की आवश्यकता होती है – क्षमता बहुत बड़ी बनाई जा सकती है। आजकल, दर्जनों या सैकड़ों गीगाबाइट आम हैं।

लेकिन संधारित्रों में एक जानलेवा खामी है: वे आवेश खो देते हैं। यदि उन्हें छोड़ दिया जाए, तो 1 का प्रतिनिधित्व करने वाला आवेश मिलीसेकंड के भीतर पूरी तरह से लीक हो जाता है, 0 बन जाता है। इसलिए मदरबोर्ड में एक समर्पित नियंत्रण सर्किट होना चाहिए जो अत्यंत छोटे अंतराल पर मेमोरी से डेटा पढ़े और उसे रिचार्ज करे। इसे डायनेमिक रिफ्रेश कहा जाता है। यही कारण है कि जब आप अपने कंप्यूटर को अनप्लग करते हैं, तो मेमोरी में सब कुछ तुरंत गायब हो जाता है।

अब हमारे पास एक ALU है जो गणित कर सकता है, और रजिस्टर और मेमोरी हैं जो डेटा संग्रहीत कर सकते हैं। मुख्य प्रश्न यह है: ये निर्जीव चीजें वास्तव में चलना कैसे शुरू करती हैं? उन्हें पहले जोड़ने, फिर गुणा करने और अंत में परिणाम संग्रहीत करने का आदेश कौन देता है?

यह नियंत्रण इकाई का काम है, और यह मुख्य तंत्र है जो कंप्यूटर को एक मशीन बनाता है।

मदरबोर्ड में एक क्रिस्टल ऑसिलेटर होता है – एक क्वार्ट्ज क्रिस्टल जो बिजली लगे रहने पर एक निश्चित आवृत्ति का पल्स सिग्नल उत्पन्न करता है। उदाहरण के लिए, यदि आपका CPU 4.0 GHz पर रेटेड है, तो इसका मतलब है कि यह क्रिस्टल हर सेकंड 4 अरब उच्च-से-निम्न वोल्टेज ट्रांज़िशन उत्पन्न करता है।

यह कंप्यूटर की दिल की धड़कन है। CPU के अंदर सभी लॉजिक गेट्स और फ्लिप-फ्लॉप इस दिल की धड़कन के साथ सख्त तालमेल में काम करते हैं।

CPU के अंदर, एक बहुत ही विशेष रजिस्टर होता है जिसे प्रोग्राम काउंटर कहा जाता है। इसमें केवल एक मेमोरी पता होता है।

जब दिल की धड़कन का पहला बीट बजता है, CPU पहली चीज़ करता है: निर्देश लाना। यह मदरबोर्ड पर धातु के निशानों के माध्यम से प्रोग्राम काउंटर में संग्रहीत पते को मेमोरी को भेजता है। मेमोरी उस पते पर संग्रहीत 0 और 1 की लंबी स्ट्रिंग वापस CPU को भेजती है।

0 और 1 की यह लंबी स्ट्रिंग निर्देश है। निर्देश CPU पर वापस आने के बाद, यह नियंत्रण इकाई में प्रवेश करता है। नियंत्रण इकाई भी केवल हार्डवायर्ड लॉजिक गेट्स का एक समूह है – इसका काम डिकोड करना है। उदाहरण के लिए, जब यह देखता है कि आने वाले 0 और 1 के पहले कुछ अंक 1011 हैं, तो इसकी आंतरिक वायरिंग संरचना निर्धारित करती है कि ये उच्च और निम्न वोल्टेज ALU में जोड़ सर्किट की ओर जाने वाले स्विच को सक्रिय करते हैं। साथ ही, निर्देश का शेष भाग निर्दिष्ट करता है कि किन रजिस्टरों में जोड़े जाने वाले दो डेटा मान हैं।

जब अगला बीट बजता है, निष्पादन चरण शुरू होता है। सक्रिय जोड़ सर्किट डेटा प्राप्त करता है, विद्युत संकेत एक पल में योजक के लॉजिक गेट नेटवर्क के माध्यम से चमकते हैं, और परिणाम उत्पन्न होता है।

अगले बीट पर, परिणाम निर्दिष्ट रजिस्टर में वापस लिखा जाता है।

अंत में, प्रोग्राम काउंटर स्वचालित रूप से एक से बढ़ जाता है, मेमोरी में अगले निर्देश की ओर इशारा करता है। फिर चक्र दोहराता है। अरबों बार प्रति सेकंड।

कंप्यूटर कैसे चलता है इसकी यह पूरी सबसे निचले स्तर की सच्चाई है। कोई उन्नत बुद्धिमत्ता नहीं है – केवल एक क्रिस्टल ऑसिलेटर जो आंख मूंदकर टिक-टिक करता है, एक प्रोग्राम काउंटर जो यांत्रिक रूप से पतों को बढ़ाता है, एक नियंत्रण इकाई जो पढ़े गए 0 और 1 के आधार पर रोबोटिक रूप से सिग्नल पथ बदलती है, और एक ALU जो आने वाले वोल्टेज स्तरों को निष्क्रिय रूप से नए वोल्टेज स्तरों में परिवर्तित करता है।

आप अपने दैनिक काम में जो Python कोड या Java कोड लिखते हैं, वह अंततः कंपाइलर नामक एक सॉफ़्टवेयर द्वारा विशिष्ट CPU आर्किटेक्चर के लिए मशीन निर्देशों के एक लंबे, नीरस अनुक्रम में अनुवादित होता है – शुद्ध 0 और 1।

इस बिंदु पर, आपने वास्तव में रेत (सिलिकॉन) से प्रोग्राम तक की पूरी श्रृंखला पूरी कर ली है। कई लोग इस स्तर पर महसूस करते हैं कि वे समझ गए, लेकिन आज के वास्तविक उद्योग के माहौल में, केवल पारंपरिक CPU सिद्धांतों को समझना पासिंग ग्रेड तक भी नहीं पहुंचता।

वर्तमान सबसे गर्म विषय AI बड़े मॉडलों को ध्यान में रखते हुए, मुझे आपके क्षितिज का विस्तार करना होगा। आइए देखें कि आज वास्तविक कंप्यूटिंग शक्ति का परिदृश्य कैसा है।

आज बड़े मॉडलों पर काम करने वाली कोई भी टीम, चाहे प्रशिक्षण के लिए या अनुमान के लिए, गणना करने के लिए CPU का उपयोग बिल्कुल नहीं कर सकती। क्यों?

क्योंकि CPU जटिल तार्किक नियंत्रण को संभालने के लिए डिज़ाइन किए गए हैं। एक CPU को देखें: इसका एक बड़ा हिस्सा शाखा भविष्यवाणी, कैश प्रबंधन और नियंत्रण इकाई के लिए समर्पित है। शुद्ध संख्यात्मक गणना के लिए वास्तव में उपयोग किया जाने वाला भाग – ALU – उतना बड़ा नहीं है। यह ऐसा है जैसे CPU एक उच्च शिक्षित बुद्धिजीवी है जो जटिल प्रबंधन प्रक्रियाओं में माहिर है। उसे 1+1 की गणना करने के लिए कहें, वह कर सकता है, और शायद रास्ते में यह भी विश्लेषण कर सकता है कि कोई त्रुटि है या नहीं – लेकिन वह एक बार में केवल कुछ ही संभाल सकता है।

बड़े मॉडलों के मूल में गणितीय सार अत्यंत बड़े पैमाने पर मैट्रिक्स गुणा है। उदाहरण के लिए, कई हज़ार गुणा कई हज़ार के दो मैट्रिक्स को गुणा करना। इसके लिए करोड़ों गुणा और जोड़ संक्रियाओं की आवश्यकता होती है। तर्क अत्यंत सरल है – गुणा-जोड़, गुणा-जोड़ – बिना किसी जटिल शाखा के, लेकिन डेटा की मात्रा चौंका देने वाली है।

यदि आप इसकी गणना करने के लिए पारंपरिक CPU का उपयोग करते हैं, तो यह निश्चित रूप से प्रति सेकंड अरबों निर्देश निष्पादित कर सकता है, लेकिन सैकड़ों अरबों मापदंडों के सामने, यह समुद्र में एक बूंद होगी।

यह समझने के लिए कि बड़े मॉडल वास्तव में क्या गणना कर रहे हैं, यदि आपकी गणितीय अंतर्ज्ञान अभी भी रटे सूत्रों पर निर्भर करती है, तो मैं दृढ़ता से अनुशंसा करता हूं कि आप 3Blue1Brown का “Essence of Linear Algebra” देखें। समीक्षा और व्युत्पत्ति को आसान बनाने के लिए, आप इसे चीनी और अंग्रेजी में 3Blue1Brown नोट्स के इस संकलित सेट के साथ जोड़ सकते हैं। यह उन्नत मैट्रिक्स गुणा और रैखिक परिवर्तनों के वास्तविक सहज ज्ञान युक्त दृश्य प्राप्त करता है। इसे देखने के बाद, आपके पास हजारों मापदंडों में गुणा-संचय संक्रियाओं की एक वास्तविक भौतिक-स्तरीय मानसिक छवि होगी।

3Blue1Brown रैखिक बीजगणित नोट्स: संभवतः वेब पर सबसे अच्छा चीनी-अंग्रेजी संकलन

इस बड़े पैमाने के मैट्रिक्स गणना की प्रकृति ने GPU, ग्राफिक्स प्रोसेसिंग यूनिट को जन्म दिया – जिसे अब सामान्य-उद्देश्य समानांतर गणना इकाई कहा जाना चाहिए।

GPU का डिज़ाइन दर्शन CPU के बिल्कुल विपरीत है। यह अधिकांश जटिल नियंत्रण सर्किटरी और बड़े कैश को हटा देता है, मुक्त हुए हर भौतिक स्थान को सबसे सरल संभव ALU से भर देता है। वर्तमान NVIDIA H100 चिप में दसियों हज़ार कंप्यूट कोर होते हैं। हालांकि प्रत्येक कोर CPU कोर से कम आवृत्ति पर चल सकता है और इसमें कमजोर नियंत्रण तर्क है, वे सभी एक साथ काम कर सकते हैं।

GPU को 100,000 प्राथमिक विद्यालय के छात्रों की एक टुकड़ी के रूप में सोचें जो केवल अंकगणित जानते हैं। आप उन्हें एक अत्यंत सरल आदेश देते हैं: अपनी बाईं ओर की संख्या को अपनी दाईं ओर की संख्या से गुणा करें। सभी 100,000 छात्र एक ही क्लॉक टिक पर एक साथ परिणाम की गणना करते हैं। बड़े मॉडलों के लिए आवश्यक बड़े पैमाने पर समानांतर मैट्रिक्स संक्रियाओं के लिए, GPU, CPU की तुलना में सैकड़ों से हज़ारों गुना अधिक कुशल है।

वास्तव में, AI – CPU के योजक की तरह – वास्तव में इतना रहस्यमय नहीं है। यह अभी भी तर्क और मैट्रिक्स की परत दर परत है। यदि आप शुरू से गहन शिक्षण की अपनी समझ बनाना चाहते हैं, तो मैं एक पुस्तक की अनुशंसा करता हूं जिसे ट्विटर पर कई लोगों ने AI को पूरी तरह से रहस्यमुक्त करने के लिए सराहा है: Deep Learning with Python। एक बार जब आप आगे और पीछे प्रसार में टेंसर गणनाओं को समझ लेते हैं, तो आप महसूस करेंगे कि बड़े मॉडलों के अंदर भी कोई जादू नहीं है।

इस पुस्तक को पढ़ने के बाद, मैं AI के बारे में पूरी तरह से रहस्यमुक्त हो गया!

हार्डवेयर पर वापस। जब हम निम्न-स्तरीय एल्गोरिदम अनुकूलन करते हैं, तो हमारा अधिकांश प्रयास VRAM बैंडविड्थ से लड़ने में जाता है। यह वह जगह भी है जहां कई उन्नत प्रोग्रामर गलती करते हैं।

क्योंकि ALU बहुत तेज़ गणना करता है। जैसा कि पहले उल्लेख किया गया है, मेमोरी मॉड्यूल संधारित्रों को चार्ज और डिस्चार्ज करके डेटा संग्रहीत करते हैं, और वे CPU या GPU से कुछ भौतिक दूरी पर होते हैं – विद्युत संकेतों को मदरबोर्ड पर यात्रा करने में समय लगता है। आज AI चिप्स के सामने सबसे बड़ी चुनौती वह है जिसे शिक्षा जगत वॉन न्यूमैन बाधा कहता है।

अर्थात: हज़ारों कंप्यूट कोर एक पल में अपने हाथों में डेटा संसाधित करना समाप्त कर देते हैं, और फिर वे केवल निष्क्रिय बैठ सकते हैं, धीमी मेमोरी से नए डेटा के स्थानांतरित होने की प्रतीक्षा करते हुए। भले ही आप चिप पर गणना सर्किट को तेज़ बना दें, यदि आप पर्याप्त तेज़ी से डेटा नहीं खिला सकते, तो कंप्यूटिंग शक्ति बर्बाद हो जाती है।

इस समस्या को हल करने के लिए, हार्डवेयर इंजीनियरों को चरम सीमा पर धकेल दिया गया है। चूंकि सामान्य मेमोरी मॉड्यूल बहुत दूर और बहुत धीमे हैं, तो क्यों न मेमोरी और GPU चिप को सीधे एक ही सब्सट्रेट पर पैकेज किया जाए? डेटा ट्रांसमिशन के लिए चैनल की चौड़ाई बढ़ाने के लिए, पारंपरिक तारों के बजाय, वे सिलिकॉन इंटरपोज़र नामक तकनीक का उपयोग करते हैं – सिलिकॉन के अंदर हजारों सूक्ष्म प्रवाहकीय छेद ड्रिल करके मेमोरी और कंप्यूट कोर को सीधे जोड़ने के लिए। इसे हाई बैंडविड्थ मेमोरी, या HBM के रूप में जाना जाता है।

यदि यह भाग आपको गहराई से उत्साहित करता है और आप आने वाले AI युग में एक अपरिहार्य उच्च वेतन वाले आर्किटेक्ट या निम्न-स्तरीय डेवलपर बनना चाहते हैं, तो मैं दृढ़ता से अनुशंसा करता हूं कि आप Computer Architecture: A Quantitative Approach पढ़ें। यह पुस्तक दो ट्यूरिंग पुरस्कार विजेताओं द्वारा लिखी गई है, और सिलिकॉन वैली में लगभग हर हार्डवेयर इंजीनियर के पास इसकी एक प्रति है। यह वास्तविक डेटा और सूत्रों की भारी मात्रा का उपयोग करके बताती है कि चिप्स को विशिष्ट कैश आर्किटेक्चर के साथ क्यों डिज़ाइन किया जाना चाहिए और मल्टी-कोर समानांतरता में बाधाएं वास्तव में कहां हैं। हालांकि इसे पढ़ना अविश्वसनीय रूप से शुष्क है, और कुछ अध्याय बहुत कठिन हैं, यह निम्न-स्तरीय समझ में संज्ञानात्मक अंतर को पाटने का आवश्यक मार्ग है।

आपके मूल प्रश्न पर वापस। ये सभी शब्द सीखने के बाद भी आप भ्रमित क्यों महसूस करते हैं? क्योंकि पारंपरिक शिक्षण भौतिक संस्थाओं और तार्किक अमूर्तताओं के बीच के मजबूत संबंध को तोड़ देता है।

जब आप CPU को एक जादुई ब्लैक बॉक्स के रूप में मानते हैं, तो वे शब्द समझ से बाहर की परिभाषाओं की तरह लगते हैं। लेकिन यदि आप भौतिकी के नियमों का पालन ऊपर की ओर करते हैं:

• क्योंकि उच्च और निम्न वोल्टेज लॉजिक गेट्स बना सकते हैं, हमें अंकगणितीय इकाइयां मिलीं जो गणित कर सकती हैं।
• क्योंकि फीडबैक सर्किट वोल्टेज अवस्थाओं को लॉक कर सकते हैं, हमें रजिस्टर मिले जो डेटा संग्रहीत कर सकते हैं।
• क्योंकि हमें विद्युत संकेतों के प्रवाह को लयबद्ध रूप से नियंत्रित करने की आवश्यकता थी, हमें क्रिस्टल ऑसिलेटर और नियंत्रण इकाइयां मिलीं।
• क्योंकि यह प्रणाली मनुष्यों के लिए सीधे वोल्टेज स्तर इनपुट करने के लिए बहुत जटिल है, हमने निर्देश सेट का आविष्कार किया, 0 और 1 को असेंबली भाषा में लपेटा, और अंत में C और Python में लपेटा।

इस उद्योग में कड़ी मेहनत करने वाले एक व्यवसायी के रूप में, मैं आपको बहुत जिम्मेदारी से बता सकता हूं: इस युग में, फ्रंटएंड फ्रेमवर्क आते और जाते हैं, बैकएंड माइक्रोसर्विस आर्किटेक्चर कुछ वर्षों के लिए अपना समय बिताते हैं, और यहां तक कि AI बड़े मॉडल आर्किटेक्चर भी तेज गति से विकसित हो रहे हैं। आज आप जो कई उच्च-स्तरीय एप्लिकेशन डेवलपमेंट तकनीक सीखते हैं, वे अगले साल अप्रचलित हो सकती हैं। वास्तव में, बड़े मॉडल स्वयं पहले से ही कई बुनियादी कोडिंग कार्यों को औसत प्रोग्रामर से बेहतर कर सकते हैं।

लेकिन एक चीज जो कभी नहीं बदलती, वह है अर्धचालक भौतिकी में निहित कंप्यूटर संचालन के ये बुनियादी सिद्धांत। कोई फर्क नहीं पड़ता कि सॉफ्टवेयर कैसे अमूर्त किया जाता है, कोई फर्क नहीं पड़ता कि एल्गोरिदम कितने परिष्कृत हो जाते हैं, सब कुछ अंततः सिलिकॉन के एक टुकड़े पर वोल्टेज के उतार-चढ़ाव तक आता है। प्रदर्शन अनुकूलन जितना उन्नत होगा, कंप्यूट शेड्यूलिंग जितनी अत्याधुनिक होगी, इंजीनियरों को उतनी ही अधिक सभी सॉफ्टवेयर अमूर्त परतों के माध्यम से देखने और अंतर्निहित हार्डवेयर की संचालन स्थिति को सीधे समझने की क्षमता की आवश्यकता होती है।

यह मत सोचिए कि यह निम्न-स्तरीय ज्ञान आपसे दूर है। जब आप अत्यधिक प्रदर्शन-भूखे कोड के एक टुकड़े का सामना करते हैं, और क्योंकि आप सबसे निचले स्तर पर कैश लाइन तंत्र को समझते हैं, आप मेमोरी में सरणियों की व्यवस्था को समायोजित करते हैं ताकि CPU कैश हिट दरों में नाटकीय रूप से सुधार हो – जिससे कोड दस गुना तेज़ चले – उस पल में, आप अंतर्निहित सिद्धांतों में महारत हासिल करने से आने वाली विशाल नियंत्रण की भावना महसूस करेंगे।