सभी कोर्स मुफ़्त · कोई खाता नहीं · आपके ब्राउज़र में

Neural Networks: न्यूरॉन से ट्रांसफ़ॉर्मर तक

neural networks ख़ुद बनाएँ, एक न्यूरॉन से एक transformer तक, फिर generative models, diffusion, scaling laws और एक model के अंदर देखना, सादे Python और NumPy में, आपके ब्राउज़र में train। अपना autograd लिखें, टूटे runs का निदान करें, दावों को सबूत से परखें, और एक capstone के साथ ख़त्म करें जिसे आप फिर चला सकें। मुफ़्त, बिना खाते के।

25 मॉड्यूल 246 पाठ 246 अपने आप जाँचे जाने वाले अभ्यास अपनी गति से · लगभग 143 घंटे की सामग्री आपके ब्राउज़र में ट्रेन किया गया, GPU की ज़रूरत नहींपहले कर्व का अनुमान लगाएँ, फिर उसे चलाएँ
आपकी प्रगति 0 / 246 अभ्यास पूरे
रोज़ का लक्ष्य
समय: 60 मिनट

Module 0: शुरुआती रेखा

आप कर पाएँगे: बताना कि कोर्स कैसे काम करता है और क्या मापता है; एक अनुमान लगाना और उसे एक run से जाँचना; चार dials पर अपना शुरुआती अंक दर्ज करना; अपने device की गति FLOPs में मापना।

समय: लगभग 8 घंटे

Module 1: इस कोर्स के लिए Python

आप कर पाएँगे: lists और dictionaries पर functions लिखना और test करना; loops के बजाय NumPy arrays, shapes, slicing और broadcasting इस्तेमाल करना; बेतरतीबी को दोहराने लायक seed करना; छोटी classes और closures लिखना। Python gate से जाँचा (पहले से धाराप्रवाह? इसे पहले लें: पास होना module छुड़वाता है)।

✓ 5 असली data पर lists और loops अभ्यास 25 मिनट देखें ✓ 6 Functions जिन्हें आप test कर सकते हैं अभ्यास 25 मिनट देखें ✓ 7 Dictionaries और गिनती अभ्यास 25 मिनट देखें ✓ 8 एक error message पढ़ना अभ्यास 25 मिनट देखें ✓ 9 NumPy arrays: lists क्यों नहीं अभ्यास 10 मिनट देखें ✓ 10 आकार (shapes): rows, columns, batches अभ्यास 45 मिनट देखें ✓ 11 एक image से टुकड़े काटना अभ्यास 15 मिनट देखें ✓ 12 loops को पूरे-array गणित से बदलना अभ्यास 20 मिनट देखें ✓ 13 Random संख्याएँ जिन्हें आप दोहरा सकते हैं अभ्यास 15 मिनट देखें ✓ 14 Mean, spread और normalise करना अभ्यास 20 मिनट देखें ✓ 15 एक function plot करना अभ्यास 20 मिनट देखें ✓ 16 एक loss वक्र पढ़ना अभ्यास 25 मिनट देखें ✓ 17 एक छोटा dataset load करना अभ्यास 20 मिनट देखें ✓ 18 धीमा हिस्सा ढूँढना अभ्यास 20 मिनट देखें ✓ 19 Objects जो याद रखते हैं (classes और closures) अभ्यास 65 मिनट देखें ✓ 20 छोटी project: धकेलकर एक रेखा fit करें अभ्यास 45 मिनट देखें ✓ 21 Gate: इस कोर्स के लिए Python (AI बंद) अभ्यास 55 मिनट देखें
7 में से चरण 1 · नेटवर्क परत शुरुआती रेखा इसकी परत पाने के लिए इस चरण के सभी 5 अभ्यास पास करें।
समय: लगभग 7 घंटे

Module 2: गणित और probability, बस ज़रूरत भर

आप कर पाएँगे: dot products, matrix गुणा और broadcasts निकालना; धकेलकर और chain rule से ढलानें ढूँढना, संख्याओं और पूरे matrices के लिए; समझाना कि फैलाव कैसे जुड़ता है और एक eigenvalue क्या करता है; softmax gradient निकालना; ऐसे log-sum-exp, softmax और cross-entropy लिखना जो कभी overflow न हों (gate)।

✓ 22 संख्याओं की सूचियों के रूप में घर (vectors) अभ्यास 20 मिनट देखें ✓ 23 dot product, और एक neuron एक क्यों है अभ्यास 20 मिनट देखें ✓ 24 Matrix गुणा: एक पूरी layer एक साथ अभ्यास 15 मिनट देखें ✓ 25 Broadcasting: जब आकार खिंचते हैं अभ्यास 50 मिनट देखें ✓ 26 धकेलकर ढलानें (derivatives) अभ्यास 10 मिनट देखें ✓ 27 एक धक्का आगे बढ़ाना (chain rule) अभ्यास 25 मिनट देखें ✓ 28 backward सस्ता क्यों है (reverse mode) अभ्यास 20 मिनट देखें ✓ 29 पूरे matrices के gradients (आकार नियम) अभ्यास 15 मिनट देखें ✓ 30 संयोग, औसत और फैलाव अभ्यास 20 मिनट देखें ✓ 31 घंटी वक्र (Gaussians) अभ्यास 20 मिनट देखें ✓ 32 फैलाव कैसे जुड़ता है, और एक matrix क्या खींचता है अभ्यास 50 मिनट देखें ✓ 33 कौन-सा अनुमान data को सबसे अच्छा समझाता है (likelihood) अभ्यास 20 मिनट देखें ✓ 34 अंकों से probabilities (softmax) अभ्यास 20 मिनट देखें ✓ 35 Cross-entropy भेस में likelihood है अभ्यास 20 मिनट देखें ✓ 36 softmax का gradient, और loss इसे क्यों छिपाता है अभ्यास 25 मिनट देखें ✓ 37 दो अनुमान कितने अलग हैं (KL divergence) अभ्यास 20 मिनट देखें ✓ 38 Gate: गणित, code में (AI बंद) अभ्यास 35 मिनट देखें
समय: लगभग 8 घंटे

Module 3: Neuron से MLP तक

आप कर पाएँगे: NumPy में एक neuron, activations और एक दो-layer network बनाना; हाथ से backprop निकालना और उसे एक gradient checker से जाँचना; एक अंक पाठक को 95% से आगे train करना; एक नए dataset के लिए अपना network बनाना और train करना (gate)।

✓ 39 एक neuron एक क़ीमत का अनुमान लगाता है (linear regression) अभ्यास 20 मिनट देखें ✓ 40 ढलान नीचे चलना (हाथ से gradient descent) अभ्यास 35 मिनट देखें ✓ 41 हाँ या ना जवाब (logistic regression) अभ्यास 40 मिनट देखें ✓ 42 उत्पादक विफलता: एक neuron से XOR अभ्यास 30 मिनट देखें ✓ 43 एक छिपी layer XOR हल करती है देखें 20 मिनट देखें ✓ 44 Activations: layers के बीच का मोड़ अभ्यास 40 मिनट देखें ✓ 45 उभारों से कोई भी वक्र (universal approximation) देखें 30 मिनट देखें ✓ 46 एक gradient checker जो आप पूरे कोर्स में इस्तेमाल करेंगे अभ्यास 45 मिनट देखें ✓ 47 Softmax और cross-entropy साथ में अभ्यास 30 मिनट देखें ✓ 48 एक दो-layer net के लिए backprop, हाथ से देखें 30 मिनट देखें ✓ 49 सादे NumPy में एक अंक पाठक अभ्यास 105 मिनट देखें ✓ 50 Gate: एक नए dataset के लिए एक network (AI बंद) अभ्यास 75 मिनट देखें
समय: लगभग 8 घंटे

Module 4: आपका अपना autograd engine

आप कर पाएँगे: एक reverse-mode autograd engine बनाना (graph, topological क्रम, backward नियम, broadcasting, reductions); उसे धकेलने से जाँचना; उस पर बिना हाथ से लिखे gradients के एक network train करना; अकेले एक नया operation जोड़ना (gate)।

✓ 51 शुरुआत: दस lines जो एक अंक पाठक train करती हैं अभ्यास 10 मिनट देखें ✓ 52 संख्याएँ आगे, gradients पीछे देखें 20 मिनट देखें ✓ 53 एक Tensor: एक array जो याद रखता है अभ्यास 15 मिनट देखें ✓ 54 graph दर्ज करना और उसे क्रम देना अभ्यास 45 मिनट देखें ✓ 55 add और multiply के लिए backward अभ्यास 40 मिनट देखें ✓ 56 matrix multiply के लिए backward अभ्यास 15 मिनट देखें ✓ 57 जब आकार खिंचते हैं तब backward (broadcasting) अभ्यास 25 मिनट देखें ✓ 58 Sums, means, reshapes और transposes अभ्यास 35 मिनट देखें ✓ 59 एक कदम में softmax और cross-entropy अभ्यास 60 मिनट देखें ✓ 60 checker को अपने engine की ओर मोड़ें अभ्यास 60 मिनट देखें ✓ 61 Layers जो अपने weights ख़ुद रखती हैं अभ्यास 60 मिनट देखें ✓ 62 अंक पाठक, आपके अपने engine पर अभ्यास 40 मिनट देखें ✓ 63 Gate: एक नया operation जोड़ें (AI बंद) अभ्यास 30 मिनट देखें
7 में से चरण 2 · नेटवर्क परत नींव इसकी परत पाने के लिए इस चरण के सभी 3 अभ्यास पास करें।
समय: लगभग 6 घंटे

Module 5: Optimisation

आप कर पाएँगे: समझाना कि एक खिंचा परिदृश्य धीमा क्यों है; minibatch SGD, momentum, RMSProp, Adam और AdamW, schedules और clipping बनाना; एक budget में, एक अनदेखी समस्या के लिए एक optimiser चुनना और tune करना (gate)।

समय: लगभग 4 घंटे

Module 6: शुरुआती weights और normalisation

आप कर पाएँगे: गहराई से signals मापना और Xavier, LeCun या He पैमाने चुनना; मरी units ढूँढना; BatchNorm forward और backward, LayerNorm और RMSNorm बनाना; train/eval जाल से बचना; गहरे networks में shortcuts इस्तेमाल करना।

समय: लगभग 4 घंटे

Module 9: क्या यह सचमुच बेहतर है?

आप कर पाएँगे: बिना रिसाव के डेटा बाँटना; precision और recall इस्तेमाल करना; seeds पर फैलाव मापना; एक अंक पर bootstrap error bars लगाना; calibration मापना; एक paired interval से दो models की तुलना करके फ़ैसला करना (gate)।

7 में से चरण 3 · नेटवर्क परत training को काम करवाना इसकी परत पाने के लिए इस चरण के सभी 40 अभ्यास पास करें।
समय: लगभग 10 घंटे

Module 10: देखने वाले networks (CNNs)

आप कर पाएँगे: convolution, padding, pooling और उनके gradients, और im2col बनाना; घर के engine पर CNNs train करना; seeds पर दर्ज runs पढ़ना; एक आधार के विरुद्ध saliency परखना; transfer इस्तेमाल करना; एक weight budget में एक CNN design करना (gate)।

✓ 111 images MLPs को क्यों तोड़ती हैं अभ्यास 15 मिनट देखें ✓ 112 हाथ से convolution देखें 35 मिनट देखें ✓ 113 Padding, stride और pooling अभ्यास 20 मिनट देखें ✓ 114 एक unit image का कितना हिस्सा देखती है देखें 25 मिनट देखें ✓ 115 Convolution backward अभ्यास 45 मिनट देखें ✓ 116 तेज़ convolution: एक बड़ा matrix गुणा (im2col) देखें 40 मिनट देखें ✓ 117 वही गणित कई गुना तेज़ क्यों चल सकता है अभ्यास 20 मिनट देखें ✓ 118 कम bits: float32, float16 और loss scaling अभ्यास 30 मिनट देखें ✓ 119 अंकों पर एक छोटा CNN अभ्यास 75 मिनट देखें ✓ 120 गहरे networks, और दर्ज runs अभ्यास 60 मिनट देखें ✓ 121 network क्या देखता है, परखा अभ्यास 100 मिनट देखें ✓ 122 एक प्रशिक्षित network फिर इस्तेमाल करना (transfer learning) अभ्यास 65 मिनट देखें ✓ 123 वापस ऊपर जाना: upsampling और transposed convolution अभ्यास 35 मिनट देखें ✓ 124 Gate: एक नए image काम के लिए एक CNN (AI बंद) अभ्यास 60 मिनट देखें
समय: लगभग 4 घंटे

Module 11: memory वाले networks (RNNs)

आप कर पाएँगे: एक RNN और एक अक्षर model बनाना; backprop through time निकालना; vanishing gradients मापना; LSTM gates बनाना; दर्ज memory और bottleneck प्रयोग पढ़ना; temperature के साथ नमूना लेना; एक टूटे recurrent model की मरम्मत करना (gate)।

समय: लगभग 6 घंटे

Module 12: संख्याओं के रूप में शब्द (embeddings)

आप कर पाएँगे: एक embedding को एक lookup मानना; एक जोड़ी-मिलाने वाला tokenizer बनाना; गिनकर और skip-gram से शब्द vectors बनाना; उनकी नक़ल किया एक skew मापना और हटाना; यह सब अकेले एक ऐसी दुनिया पर करना जो आपने नहीं देखी (gate)।

समय: लगभग 10 घंटे

Module 13: Attention और transformers

आप कर पाएँगे: attention, causal mask, heads, positions, layer norm और एक पूरा block बनाना जो एक असली model से मेल खाए; attention का backward pass निकालना; एक छोटा GPT train करना; दर्ज runs पढ़ना; एक cache के साथ बनाना; अपने engine को PyTorch पर मैप करना; एक टूटे transformer की मरम्मत करना (gate)।

✓ 141 Attention एक नरम खोज है देखें 20 मिनट देखें ✓ 142 d के square root से भाग क्यों अभ्यास 45 मिनट देखें ✓ 143 Attention bottleneck ठीक करता है अभ्यास 40 मिनट देखें ✓ 144 Self-attention: हर स्थिति हर दूसरी से पूछती है अभ्यास 20 मिनट देखें ✓ 145 causal mask: कोई झाँकना नहीं देखें 45 मिनट देखें ✓ 146 attention से backward अभ्यास 25 मिनट देखें ✓ 147 कई heads, वही लागत देखें 40 मिनट देखें ✓ 148 Attention को क्रम का कोई बोध नहीं अभ्यास 50 मिनट देखें ✓ 149 लहरों के रूप में स्थितियाँ अभ्यास 50 मिनट देखें ✓ 150 Layer norm: हर vector को सीमा में रखें अभ्यास 20 मिनट देखें ✓ 151 एक transformer block, हाथ से देखें 60 मिनट देखें ✓ 152 parameters कहाँ हैं अभ्यास 10 मिनट देखें ✓ 153 एक नन्हा GPT train करें, live अभ्यास 25 मिनट देखें ✓ 154 चौड़े models छोटे steps चाहते हैं अभ्यास 60 मिनट देखें ✓ 155 heads क्या देखते हैं अभ्यास 40 मिनट देखें ✓ 156 तेज़ बनाना: key-value cache देखें 40 मिनट देखें ✓ 157 आपका engine, PyTorch के शब्दों में अभ्यास 25 मिनट देखें ✓ 158 Gate: एक टूटा transformer (AI बंद) अभ्यास 15 मिनट देखें
समय: लगभग 4 घंटे

Module 14: Run Clinic II, sequence models का इलाज

आप कर पाएँगे: टूटे sequence models का निदान करना, जिनमें बढ़िया दिखती धोखाधड़ियाँ, रुकावटें, step आकार और sampling गड़बड़ियाँ शामिल हैं; विफल दर्ज runs पढ़ना; एक AI सहायक को सबूत से परखना; एक budget पर अकेले निदान करना (gate); अपनी निकास परीक्षा की आधार से तुलना करना।

7 में से चरण 4 · नेटवर्क परत ढाँचे के लिए architectures इसकी परत पाने के लिए इस चरण के सभी 56 अभ्यास पास करें।
समय: लगभग 5 घंटे

Module 15: दबाएँ, फिर बनाएँ, बनाएँ नया (autoencoders और VAEs)

आप कर पाएँगे: अंकों को कुछ संख्याओं में दबाना और उन्हें फिर बनाना; मापों के साथ बताना कि एक autoencoder नए अंक क्यों नहीं बना सकता; दो घंटी वक्रों के बीच KL और ELBO निकालना; ऐसे sample करना जिससे आप train कर सकें; एक VAE train करना जो नए अंक बनाए; अंकों के बीच चलना; अकेले एक ढहे VAE का निदान और इलाज करना (gate)।

समय: लगभग 4 घंटे

Module 16: एक खेल में दो networks (GANs, वैकल्पिक)

वैकल्पिक module, प्रमाणपत्र के लिए ज़रूरी नहीं। आप कर पाएँगे: GAN losses लिखना और उनकी ढलानों से बताना कि saturating वाला कब रुकता है; आठ blobs पर एक GAN train करना और उसके ढकाव को परखना; mode collapse करवाना; दर्ज seeds पर स्थिर करने वाली तरकीबें परखना और रिपोर्ट करना कि किसने मदद की; एक convolutional generator चलाना; अकेले एक टूटे GAN को बचाना (gate)।

समय: लगभग 8 घंटे

Module 17: शोर अंदर, तस्वीरें बाहर (diffusion)

आप कर पाएँगे: एक schedule से शोर जोड़ना, step दर step और एक छलाँग में; network के तीरों को data तक वापस पढ़ना; एक शोर अनुमानक train करना; DDPM से sample करना और बताना कि साफ़ अनुमान clip क्यों किया जाता है; मापकर शोर schedules और समय inputs की तुलना करना; एक U-Net बनाना; DDIM से कम steps में sample करना; classifier-free guidance से samples को दिशा देना; एक प्रशिक्षित model को fine-tune करना; अकेले एक नया आकार fit करना (gate)।

समय: लगभग 6 घंटे

Module 18: बिना labels के सीखना

आप कर पाएँगे: nearest-neighbour सहमति और अपने लिखे एक linear probe से features परखना; masked prediction से pretrain करना; InfoNCE लिखना और बताना कि यह cross-entropy क्यों है; SimCLR से pretrain करना और पढ़ना कि उसके augmentations क्या तय करते हैं; तस्वीरों से captions मिलाना (वैकल्पिक); अकेले, उन objects पर features परखना जो model ने कभी नहीं देखे (gate)।

7 में से चरण 5 · नेटवर्क परत चीज़ें बनाने वाले networks इसकी परत पाने के लिए इस चरण के सभी 26 अभ्यास पास करें।
समय: लगभग 5 घंटे

Module 19: बड़ा, और कितना बेहतर (scaling laws)

आप कर पाएँगे: एक training run की क़ीमत FLOPs में निकालना; एक फ़र्श और error bars के साथ एक power law fit करना; पढ़ना कि weights या डेटा एक run को सीमित करते हैं; एक तय budget के लिए सबसे अच्छा model आकार योजना बनाना; एक बड़े run का अनुमान लगाकर उसे जाँचना; एक असली छलाँग को एक ऐसे metric से अलग बताना जो एक बनाता है; अकेले एक run की योजना बनाना (gate)।

समय: लगभग 5 घंटे

Module 20: एक प्रशिक्षित model को सस्ते में ढालना

आप कर पाएँगे: catastrophic forgetting दिखाना; LoRA गिनना, बनाना और gradient-जाँचना; मापों से उसका rank चुनना; एक model को उसे बर्बाद किए बिना अपने text पर fine-tune करना; बताना कि distillation कब मदद करता है; weights quantise करना और लागत का अनुमान लगाना; DPO से preferences tune करना और समय पर रुकना; एक स्थिति के लिए एक तरीका चुनना; अकेले एक budget पर एक ढालने का लक्ष्य पूरा करना (gate)।

समय: लगभग 8 घंटे

Module 21: एक model के अंदर देखना

आप कर पाएँगे: बताना कि एक model के अंदर के बारे में सबूत एक pattern है, एक effect या एक mechanism; एक control के साथ एक probe चलाना; जानकारी कहाँ है यह ढूँढने के लिए activations patch करना; हिस्से हटाना और backup जाँचना; सामने के model पर एक पाठ्यपुस्तक mechanism परखना; एक खिलौने में superposition दिखाना; एक sparse autoencoder train करना और अनदेखे text पर एक feature label परखना; दर्ज runs से grokking पढ़ना और उसकी लहरों को हटाकर जाँचना; बस नए inputs पर जानकारी कहाँ है यह ढूँढना (gate)।

समय: लगभग 5 घंटे

Module 22: दावों को परखना

आप कर पाएँगे: overlap से एक रिसा test set ढूँढना और साफ़ अंक रिपोर्ट करना; एक औसत loss को उस हिस्से पर बाँटना जो मायने रखता है; बताना कि zero और mean ablation कैसे अलग हैं और तरीका रिपोर्ट करना; standard errors से एक-seed के अंतर को एक मापे अंतर से अलग बताना; एक नतीजे को नए seeds पर दोहराना और वह setting ढूँढना जहाँ वह टिकना बंद करता है; अकेले एक दावे की समीक्षा करना (gate)।

7 में से चरण 6 · नेटवर्क परत Scale और समझ इसकी परत पाने के लिए इस चरण के सभी 36 अभ्यास पास करें।
समय: लगभग 7 घंटे

Module 23: Capstone studio: एक model card जिसे आप चला सकें

आप कर पाएँगे: एक FLOP budget के साथ एक प्रोजेक्ट की योजना बनाना; seeds पर एक baseline का अनुमान लगाना और चलाना; error bars से बदलावों को परखना; gradient checking से एक bug ढूँढना जो फिर भी train होता है; एक untrained control के मुक़ाबले अपने model के अंदर एक खोज करना; error bars के साथ एक छिपे set पर एक बार मूल्यांकन करना; एक model card लिखना जिसकी हर संख्या आपके run log से मेल खाए; एक offline फ़ाइल export करना जिसके runs फिर चलें।

समय: 50 मिनट

Module 24: अंतिम परीक्षा और दोबारा परीक्षा

आप कर पाएँगे: AI बंद के साथ, दिखाना कि Part 2 ने चारों dials पर क्या सिखाया (form C); शुरुआती रेखा से Part 2 के अंत तक अपने dials की तुलना करना; एक महीने बाद जाँचना कि क्या टिका (form D, वैकल्पिक)।

7 में से चरण 7 · नेटवर्क परत Capstone और सबूत इसकी परत पाने के लिए इस चरण के सभी 10 अभ्यास पास करें।