AI युग के लिए GPU सर्वाइवल टूलकिट

 (journal.hexmos.com)
3 पॉइंट द्वारा GN⁺ 2023-11-13 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • AI development अब सिर्फ CPU-स्टाइल sequential execution से पूरा नहीं चल सकता; training और inference performance को सही तरह संभालने के लिए GPU के बड़े पैमाने वाले parallel processing model को समझना ज़रूरी है
  • Consumer-grade CPU में आम तौर पर 2~16 cores होते हैं और वे single-thread व conditional-branching tasks में मजबूत होते हैं, जबकि GPU हजारों छोटे cores के साथ matrix operations, image processing और deep learning के लिए बेहतर होते हैं
  • AWS P3/P4, P5/Inf1, G4 और Amazon SageMaker जैसे GPU execution environments देता है; p3.2xlarge करीब $3.06 प्रति घंटा, p5.48xlarge $98.32, और g4dn.xlarge $0.526 के स्तर पर है
  • NVIDIA CUDA developers को GPU memory allocation, data copying, kernel execution और compilation तक की parallel execution flow को सीधे संभालने देता है
  • Array addition, Mandelbrot generation और cats-vs-dogs classification CNN examples दिखाते हैं कि sequential loops को GPU threads में कैसे बांटा जाता है; Mandelbrot में समय CPU पर 4.07 सेकंड से घटकर GPU पर 0.0046 सेकंड हो गया

सिर्फ CPU knowledge क्यों पर्याप्त नहीं है

  • कई developers ने learning और problem solving को CPU-centric approach से सीखा है, लेकिन CPU मूल रूप से sequential architecture पर आधारित होकर काम करता है
  • पारंपरिक CPU instructions को linearly execute करता है और कुछ शक्तिशाली cores को single-thread performance के लिए optimize करता है
  • जब कई tasks को एक साथ process करना होता है, तो sequential execution की वजह से हर task को बारी-बारी संभालने की लागत बढ़ जाती है
  • Multithreading से performance बढ़ाई जा सकती है, लेकिन CPU की basic design philosophy अब भी sequential execution के करीब है

AI models और parallel processing

  • Transformer जैसे modern AI architectures training performance बढ़ाने के लिए parallel processing का इस्तेमाल करते हैं
  • RNN sequentially काम करते हैं, लेकिन GPT जैसे Transformer कई words को एक साथ process कर सकते हैं, जिससे training efficiency और model capability बढ़ती है
  • Parallel training बड़े models को संभव बनाती है, और बड़े models बेहतर output देने की बुनियाद बन सकते हैं
  • Parallelism natural language processing के अलावा image recognition पर भी लागू होता है
    • AlexNet image के अलग-अलग हिस्सों को एक साथ process कर patterns identify करने का उदाहरण है
  • Single-thread performance-centric design के कारण CPU complex AI models के लिए जरूरी बड़े पैमाने की parallel calculations को efficiently distribute और execute करने में कठिनाई महसूस करता है

GPU bottleneck कैसे कम करता है

  • GPU को CPU के बड़े और शक्तिशाली cores की जगह बहुत सारे छोटे और specialized cores इस्तेमाल करने वाली structure के रूप में design किया गया है
  • Graphics rendering और complex mathematical calculations जैसे workloads में, जहां एक ही तरह के operations बड़े पैमाने पर repeat होते हैं, GPU की parallelism साफ दिखती है
  • TensorFlow जैसे deep learning frameworks GPU performance का इस्तेमाल करके model training और inference को accelerate करने के लिए optimized होते हैं
  • Neural network training में बहुत सारे matrix operations शामिल होते हैं, और GPU अपनी बड़ी core count के कारण इन operations को parallelize करने में मजबूत होता है

CPU और GPU की roles में अंतर

  • CPU

    • CPU को sequential processing पर focus करके design किया गया है, इसलिए यह एक instruction flow को linearly execute करने वाले tasks में मजबूत होता है
    • General-purpose computing, system tasks और conditional branching वाले complex algorithms को process करने के लिए उपयुक्त है
    • Consumer-grade CPU में आम तौर पर 2~16 cores की range में अपेक्षाकृत कम cores होते हैं
    • हर core अपना instruction set independently process कर सकता है

  • GPU

    • GPU को parallel architecture के रूप में design किया गया है, इसलिए यह एक साथ बहुत सारे sub-tasks process करने में efficient है
    • Graphics rendering, complex mathematical calculations और parallelizable algorithms execute करने में फायदेमंद है
    • Task को छोटे parallel units में बांटकर कई operations को एक साथ process करता है
    • GPU cores अक्सर हजारों की संख्या में होते हैं और streaming multiprocessors(SMs) या इसी तरह की structures से बने होते हैं
    • Image/video processing, deep learning और scientific simulation जैसे बहुत सारा data एक साथ संभालने वाले tasks के लिए उपयुक्त है

AWS पर चुने जा सकने वाले GPU environments

  • AWS machine learning जैसे tasks के लिए कई GPU instances देता है

  • General-purpose GPU instances

    • P3 और P4 general-purpose GPU instances हैं और अलग-अलग workloads के लिए उपयुक्त हैं
    • इन्हें machine learning training/inference, image processing और video encoding में इस्तेमाल किया जा सकता है
    • p3.2xlarge $3.06 प्रति घंटा है और 16GB GPU memory वाला 1 NVIDIA Tesla V100 GPU देता है

  • Inference-optimized instances

    • Inference वह process है जिसमें trained AI model में real-time data डालकर predictions किए जाते हैं या tasks हल किए जाते हैं
    • P5 और Inf1 low latency और cost efficiency महत्वपूर्ण होने वाली machine learning inference के लिए tuned हैं
    • p5.48xlarge $98.32 प्रति घंटा है और 80GB memory वाले 8 NVIDIA H100 GPUs, कुल 640GB video memory देता है

  • Graphics-optimized instances

    • G4 instances graphics-intensive tasks को संभालने के लिए design किए गए हैं
    • Video game developers G4 instances से games के लिए 3D graphics render कर सकते हैं
    • g4dn.xlarge $0.526 प्रति घंटा है और 16GB memory वाले 1 NVIDIA T4 GPU का इस्तेमाल करता है

  • Managed machine learning service

    • Amazon SageMaker machine learning के लिए managed service है और P3, P4, P5 जैसे GPU-based instances तक access देता है
    • SageMaker उन organizations के लिए उपयुक्त है जो underlying infrastructure को सीधे manage किए बिना machine learning शुरू करना चाहती हैं
    • Amazon SageMaker pricing documentation अलग से उपलब्ध है

NVIDIA CUDA का basic usage

  • CUDA NVIDIA द्वारा विकसित parallel computing platform और programming model है, जो GPU accelerators का इस्तेमाल करके applications को तेजी से चलाने देता है
  • Example CUDA development flow दिखाता है: GPU memory allocation, data copy, kernel execution और result retrieval

  • Installation flow

    • CUDA से base installer और driver installer download करें
    • Home folder की .bashrc में नीचे दिए environment variables जोड़ें
      • export PATH="/usr/local/cuda-12.3/bin:$PATH"
      • export LD_LIBRARY_PATH="/usr/local/cuda-12.3/lib64:$LD_LIBRARY_PATH"
    • नीचे दिए commands चलाएं
      • sudo apt-get install cuda-toolkit
      • sudo apt-get install nvidia-gds
    • बदलाव लागू करने के लिए system reboot करें

  • उपयोगी check commands

    • lspci | grep VGA: system के GPUs को identify और list करता है
    • nvidia-smi: NVIDIA GPU की utilization, temperature, memory usage आदि detailed information देता है
    • sudo lshw -C display: graphics card जैसे display controller information देता है
    • inxi -G: GPU और display सहित graphics subsystem की जानकारी दिखाता है
    • sudo hwinfo --gfxcard: system graphics card की detailed information जांचने के लिए इस्तेमाल होता है

CUDA से array addition parallelize करना

  • Array addition GPU parallelization समझाने के लिए उपयुक्त problem है
  • Example arrays A = [1,2,3,4,5,6], B = [7,8,9,10,11,12] हैं, और result C = [8,10,12,14,16,18] है
  • CPU approach array elements को एक-एक करके traverse करते हुए addition करता है
  • Data बढ़ने पर sequential approach का समय बढ़ता है, और GPU 1+7, 2+8, 3+9 जैसे operations को एक साथ कर सकता है
  • CUDA example .cu kernel file का इस्तेमाल करता है
    • __global__ GPU पर call होने वाले kernel function को दर्शाता है
    • vectorAdd तीन integer pointers a, b, c लेता है और vector addition करता है
    • threadIdx.x current thread का index लाता है
    • हर thread संबंधित element का sum c[i] में store करता है
  • main function GPU memory allocation, data copy, kernel execution और result copy के क्रम में चलता है
    • cudaMalloc से cudaA, cudaB, cudaC memory GPU पर allocate की जाती है
    • cudaMemcpy से a, b को host से GPU पर copy किया जाता है
    • vectorAdd <<<1, sizeof(a) / sizeof(a[0])>>> से kernel execute किया जाता है
    • Result vector cudaC को GPU से host पर copy किया जाता है
  • Compile और run करने के लिए nvcc command का इस्तेमाल होता है
  • पूरा code उपलब्ध है

Python image generation में GPU का इस्तेमाल

  • Mandelbrot set generation एक ऐसा task है जो किसी खास equation में numbers के behavior के आधार पर complex visual patterns बनाता है और resource-intensive है
  • CPU-based Python example हर pixel पर loop चलाकर Mandelbrot value calculate करता है, और 1024×1536 image generation में 4.07 सेकंड लगते हैं
  • GPU-accelerated version Numba library का इस्तेमाल करता है
    • @jit decorator Python code को machine code में बदलने वाली Just-In-Time compilation करता है
    • cuda.jit से mandel_gpu बनाया जाता है, और device=True specify करके उसे GPU पर execute होने दिया जाता है
    • mandel_kernel CUDA GPU पर execute होता है और Mandelbrot generation task को GPU threads में बांटता है
  • create_fractal_gpu GPU memory allocation, thread/block setup, GPU kernel execution, synchronization और result copy करता है
    • threadsperblock = (16, 16) का इस्तेमाल करता है
    • cuda.synchronize() से GPU task पूरा होने का इंतजार करता है
    • d_image.copy_to_host(image) से result CPU side पर copy करता है
  • GPU execution time 0.0046 सेकंड है, जो CPU-based code से कहीं ज्यादा तेज है
  • पूरा code उपलब्ध है

GPU से cats-vs-dogs classification neural network training

  • AI में GPU कैसे इस्तेमाल होता है यह दिखाने के लिए cats और dogs में फर्क करने वाला neural network example इस्तेमाल किया गया है
  • Prerequisites CUDA और TensorFlow हैं
    • TensorFlow को pip install tensorflow[and-cuda] से install किया जा सकता है
    • Dataset Kaggle Dogs vs. Cats का इस्तेमाल करता है
    • Download के बाद cats और dogs images को training folder के अलग-अलग subfolders में organize करें
  • Model convolutional neural network(CNN) का इस्तेमाल करता है
    • pandas और numpy data manipulation के लिए इस्तेमाल होते हैं
    • Sequential neural network layers को linearly stack करने के लिए इस्तेमाल होता है
    • Convolution2D, MaxPooling2D, Dense, Flatten CNN component layers हैं
    • ImageDataGenerator training के दौरान real-time data augmentation में इस्तेमाल होता है
  • Training data ImageDataGenerator से load होता है
    • Training data पर rescale=1./255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True apply होता है
    • Input images (64, 64) size, batch size 32 और binary classification mode पर set होते हैं
  • CNN structure convolution, max pooling, flattening, Dense layer और sigmoid output से बना है
  • Model adam optimizer, binary_crossentropy loss और accuracy metric के साथ compile होता है
  • Training epochs=25, validation_steps=2000 से execute होती है, और classifier.save('trained_model.h5') से .h5 file में save होती है
  • Inference code trained_model.h5 load करके image को (64, 64) में convert करता है, और predicted value 0.5 या उससे ज्यादा हो तो dog, नहीं तो cat output करता है
  • पूरा code उपलब्ध है

GPU usage का दायरा

  • AI युग में GPU capabilities को ignore करना मुश्किल है, और developers को GPU की ताकत को बेहतर समझना चाहिए
  • Sequential algorithms से parallelized algorithms की ओर बढ़ते हुए, GPU complex calculations को accelerate करने का tool बनता है
  • GPU की parallel processing capability AI और machine learning tasks में बड़े datasets और complex neural network architectures को process करने के लिए खास तौर पर फायदेमंद है
  • GPU traditional machine learning domain से आगे scientific research, simulation और data-intensive tasks में भी इस्तेमाल होता है
  • Parallel processing capability drug discovery, climate modeling और financial simulation जैसे अलग-अलग क्षेत्रों की problems solve करने में इस्तेमाल होती है

संबंधित पढ़ाई

1 टिप्पणियां

 
GN⁺ 2023-11-13
Hacker News की राय

  • इस लेख का code गलत है। CUDA kernel बिल्कुल call नहीं किया गया: https://github.com/RijulTP/GPUToolkit/blob/f17fec12e008d0d37...
    JIT-compiled code से Mandelbrot set को “compute” करने में लगने वाले समय का 90% असल computation में नहीं, बल्कि function compile करने में जाता है
    अगर आप CUDA सही तरह से सीखना चाहते हैं, तो matrix multiplication implementation अच्छा अभ्यास है, और देखने लायक tutorials ये हैं: https://cnugteren.github.io/tutorial/pages/page1.html और https://siboehm.com/articles/22/CUDA-MMM

    • CUDA में parallel math code का “Hello World” कहा जाने वाला SAXPY भी है। SAXPY “Single-Precision A·X Plus Y” का short form है, यह standard BLAS function है और scalar multiplication व vector addition को मिलाने वाला बेहद simple operation है
      यह 32-bit floating-point vectors X और Y, और scalar A लेता है, हर X[i] को A से multiply करता है और फिर Y[i] में जोड़ता है: https://developer.nvidia.com/blog/six-ways-saxpy/
    • ध्यान दिलाए जाने के बाद code ठीक कर दिया और blog भी update कर दिया

  • दावा है कि “हर developer को यह जानना चाहिए”, लेकिन असल में यह लेख AI में GPU कैसे इस्तेमाल होते हैं इस बारे में ज्यादा लगता है। ज्यादातर developers AI developers नहीं हैं, और वे AI से सीधे interact भी नहीं करते या GPU को सीधे use भी नहीं करते
    इसके अलावा GPU के अस्तित्व का मुख्य कारण, यानी 3D graphics, इसमें लगभग cover नहीं किया गया

    • पास के fields की basics जानना मददगार होता है। खासकर machine learning जैसे व्यापक रूप से लागू होने वाले field में, और हो सकता है अगले महीने मिलने वाले project में machine learning इस्तेमाल करनी पड़े, या उस हिस्से को संभालने वाले colleague के साथ collaboration में भी फायदा हो
      basic knowledge हो तो manager को बेची जाने वाली “AI” वाली बातों को भी बेहतर समझ सकते हैं
      “adjacent fields की जरूरत नहीं” वाला attitude मैंने school में अक्सर देखा था। system administration side में मेरे batchmates कहते थे कि programming जानना जरूरी नहीं, लेकिन scripting की जरूरत पड़ी; software development school में कहते थे कि networks जानना जरूरी नहीं, लेकिन कुछ साल बाद job postings में DevOps खूब दिखने लगा
      अगर लेख लगभग 1500 words का है तो पढ़ाई की तरह पढ़ने पर भी करीब 12 minutes लगेंगे, और code examples चला कर देखने में 2 घंटे भी लगें तो यह कोई बड़ा investment नहीं है। बेशक, यह मानना होगा कि वह लेख अच्छा introduction है
    • जब मैं traditional embedded company से startup में गया, तो याद है एक colleague ने friendly तरीके से मुझे tease किया कि मुझे curl से JSON request भेजना नहीं आता। मैं अब भी embedded developer हूं, लेकिन उसके बाद backend, frontend और infra काफी सीखा, और लगता है अगले कुछ सालों में पूरी industry में AI को लेकर कुछ ऐसा ही होने की संभावना काफी है
    • Mandelbrot set rendering example में भी सिर्फ 10x speedup आता है, जबकि यह floating-point operations की मात्रा से लगभग पूरी तरह bound computation का representative case है। व्यक्तिगत रूप से मुझे यह लेख बहुत खराब लगता है
    • इसमें कई inaccurate assumptions हैं। मैं इस बात से सहमत हूं कि ज्यादातर developers AI developers नहीं हैं, और लगता है original author आम developers के group से थोड़ा कटा हुआ है या अपने आसपास की दुनिया के आधार पर पूरे जगत के बारे में assumption बना रहा है
    • जब भी मैं “हर developer को यह जानना चाहिए” दावा करने वाला लेख देखता हूं, वह दावा आम तौर पर झूठा निकला है। सच में ऐसी जानकारी वाला लेख हो सकता है जो सबको जाननी चाहिए, लेकिन जो सामने आता है वह ज्यादातर clickbait होता है

  • मुझे लगता है कि AI में Python के dominant होने की वजह यह है कि Python-C relationship, CPU-GPU relationship जैसी है
    GPU की performance बहुत अच्छी है, लेकिन direct code करना मुश्किल है, इसलिए लोग PyTorch जैसे high-level API calls से GPU को handle करते हैं
    C की performance भी अच्छी है, लेकिन coding मुश्किल है, इसलिए Python को C के ऊपर abstraction layer की तरह इस्तेमाल किया जाता है
    यह साफ नहीं है कि लोगों को GPU को इतना गहराई से समझना चाहिए या नहीं। अगर आप AI training या operations के काफी अंदर तक नहीं जा रहे, तो और भी कम; और अगर Moore’s law खत्म हो जाए और multithreading speed improvements का मुख्य तरीका बन जाए, तो parallel programming paradigm के हिसाब से नई languages आने की संभावना काफी है। Mojo उस शुरुआत जैसा लगता है

    • मुझे लगा था कि क्या ऐसी नई language के लिए जगह है जो किसी भी hardware पर चले, लेकिन performance को invisibly maximize करे
      simple iterative computations से लेकर हर instruction तक, सब कुछ पीछे से intelligently सभी CPU cores को parallel में इस्तेमाल करे, और जो काम संभव हों उन्हें GPU को सौंप दे—ऐसे design के साथ
      जिज्ञासा है कि क्या ऐसा प्रयास पहले हो चुका है, या शुरुआत से ही यह possible है या नहीं
    • Moore’s law को अभी खत्म कहना मुश्किल है, और multithreading भी answer नहीं है। हालांकि पहला sentence सही है
    • GPU programming उतनी मुश्किल नहीं है। CUDA कई कामों में काफी intuitive है, और अक्सर 100 lines से कम code में 100x speedup मिल सकता है
    • ज्यादा modern language इस्तेमाल करने पर Python जैसी expressiveness बनाए रखते हुए भी C-level performance काफी आसानी से मिल सकती है। बल्कि मुझे लगता है कि C में abstraction की कमी है, इसलिए slow लेकिन simple code ज्यादा attractive दिखने लगता है
    • C जीवन जीने का तरीका है। जो लोग लगभग पूरी तरह C ही इस्तेमाल करते हैं, उनके लिए Python के “meaningful whitespace” concept को स्वीकार करना मुश्किल होता है

  • “कई tasks मिलने पर CPU resources को इस तरह allocate करता है कि हर task को एक-एक करके process करे” यह explanation बहुत oversimplified है। कभी-कभी तो लगता है काश CPU अब भी इतना simple होता
    लेख का programming model पर focus करना ठीक है, लेकिन performance perspective से “CPU instructions sequentially execute करता है” कहना मूल रूप से गलत है। pipelines instructions को parallel execute करती हैं, SIMD भी है, और कई cores एक ही problem को साथ मिलकर handle कर सकते हैं

    • लगता है इस लेख का focus गलत जगह है। AVX-512 वाले CPU में भी large-scale data parallelism होता है, और CPU भी एक साथ कई instructions execute कर सकता है
      बड़ा फर्क यह है कि CPU एक thread को efficiently execute करने के लिए control-flow handling पर बहुत silicon और power खर्च करता है, जबकि GPU वही resources ज्यादा compute units पर लगाता है और ढेर सारे threads चलाकर control flow और memory latency को hide करता है
    • CPU भी कई SIMD instructions को एक साथ execute करता है

  • यह कहना कि CPU serial code के लिए अच्छा है और GPU parallel code के लिए अच्छा है, कुछ हद तक सही है, लेकिन यह काफ़ी मोटा approximation है। अगर कुछ सौ watts के समान power budget को मानें, तो CPU में independent tasks को एक-एक करके चलाने वाले लगभग 100 “cores” होते हैं, hyperthreading सहित, और यह branch prediction व pipelining से memory latency छिपाता है
    GPU में लगभग 100 “compute units” होते हैं, और हर unit करीब 80 independent tasks को interleave करके चलाता है; दूसरे task की अगली instruction चलाकर memory latency छिपाता है
    terminology काफ़ी confusing है, और CPU में 256-bit चौड़ी vector unit, जबकि GPU में 2048-bit चौड़ी vector unit होने की संभावना ज़्यादा है, लेकिन थोड़ा दूर से देखें तो दोनों architectures काफ़ी मिलती-जुलती दिखती हैं

    • GPU की memory bandwidth CPU से करीब 10 गुना ज़्यादा होती है, और LLM में यह फर्क अहम हो जाता है। अगर batching optimal हो, तो एक output token बनाने के लिए असल में पूरी memory पढ़नी पड़ती है, क्योंकि वही memory weights या KV cache के लिए इस्तेमाल होती है
    • मुझे हमेशा हैरानी होती है कि कम latency वाले कुछ cores और high throughput वाले बहुत सारे cores को मिलाने की दिशा में ज़्यादा कोशिश क्यों नहीं दिखती। जैसे एक Intel P core को कई E cores से घेर दें, और उन E cores में बहुत सारे iGPU cores या AVX-512 units जोड़ दें
      नाम Xeon Chi रख सकते हैं

  • ज़्यादातर programming languages CPU की तरह sequential processing के हिसाब से design की गई हैं, जबकि Erlang/Elixir को GPU की तरह parallelism के लिए design किया गया मानें, तो सोचता हूँ कि क्या Nx / Axon उभरेंगे: https://github.com/elixir-nx/

    • Erlang compute-heavy parallel processing के लिए नहीं, बल्कि high-concurrency वाले distributed systems के लिए design किया गया था
    • सच में जिज्ञासा है कि Elixir और Nx high-performance computing cluster के compute-intensive कामों में कितने अच्छे चलेंगे। संरचनात्मक रूप से यह इस क्षेत्र में अक्सर इस्तेमाल होने वाले MPI से बहुत अलग नहीं है, और numpy व scientific Python ecosystem की तरह कहीं ज़्यादा accessible हो सकता है
    • मैं देख रहा हूँ कि Elixir और Nx/Axon का combo CPU और GPU मिले-जुले NVIDIA Grace Hopper जैसी architecture के लिए कितना fit बैठता है
    • जिज्ञासा है कि क्या वह GPU पर चलता है। मुझे लगता है भविष्य में दोनों की ज़रूरत होगी। sequential programming अभी भी उन ज़्यादातर कामों के लिए सबसे अच्छा abstraction है जिन्हें भारी parallel execution की ज़रूरत नहीं होती

  • buying guide चाहिए। जानना चाहता हूँ कि कम-से-कम कितना खर्च करना होगा, और budget range के हिसाब से best choice क्या है। समस्या यह है कि यह जानकारी कभी-कभी बदलती रहती है, और पता नहीं कोई लगातार updated resource है या नहीं

    • https://timdettmers.com/2023/01/30/which-gpu-for-deep-learni... निजी तौर पर मुझे सबसे अच्छा resource लगता है
    • Google Colab, Kaggle Notebooks, Paperspace Notebooks सभी अपनी limits के भीतर free GPU usage देते हैं, इसलिए GPU programming सीखने के लिए पैसे खर्च करना ज़रूरी नहीं है
      https://colab.google/
      https://www.kaggle.com/docs/notebooks
      https://www.paperspace.com/gradient/free-gpu
    • GPU programming की basics सीखने भर के लिए integrated GPU भी काफी है। वास्तविक professional applications बेशक बहुत अलग-अलग होती हैं
    • अगर अभी 1–2 हजार dollars खर्च नहीं करना चाहते, तो online compute resources rent भी किए जा सकते हैं

  • क्या हम फिर से “हर developer को जानना चाहिए” किस्म के clickbait लेखों पर लौट आए हैं

    • लगता है इस तरह का format ChatGPT से replace हो जाएगा, लेकिन अगर लेख अच्छी तरह लिखा हो तो सच में काफी valuable होता है
      मुझे complexity को सीधे address करना पसंद है, और computer hardware जैसे क्षेत्रों में quantitative methods और qualitative details दोनों की कुछ समझ है, इसलिए किसी field की details ठीक से समझाने वाले लेख अच्छे लगते हैं
      मसलन “What every programmer should know about memory” क्या हर programmer को जानना ही चाहिए, यह अलग बात है, लेकिन अच्छे programmer को computer असल में कैसे काम करता है इसका अंदाज़ा होना चाहिए। उस लेख से लेने लायक मुख्य बात locality है, जो तेज़, follow करने में आसान और problem-fit अच्छे code में अक्सर स्वाभाविक रूप से आ जाती है
    • लगता तो ऐसा ही है। इस लेख के claims को छानकर देखना चाहिए

  • अच्छा लेख है, लेकिन AWS P5 instances P4d, P4de के साथ inference के बजाय साफ़ तौर पर training के लिए ज्यादा tuned हैं। inference के लिए ज्यादा उपयुक्त instance types G4dn और G5 हैं, जो क्रमशः T4 और A10G GPU इस्तेमाल करते हैं

    • original article ने G5 छोड़ दिया था

  • GPU programming में मैं लगभग नया हूँ, लेकिन यह लेख पढ़ने में मज़ेदार लगा। यह देखकर हैरानी हुई कि technology इतनी आगे बढ़ गई है कि simple “कुत्ता या बिल्ली” neural network को इतनी आसानी से train किया जा सकता है