ชุดเครื่องมือเอาตัวรอดกับ GPU สำหรับยุค AI

 (journal.hexmos.com)
3 คะแนน โดย GN⁺ 2023-11-13 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • การพัฒนา AI ไม่อาจพึ่งพาเพียงการทำงานแบบ ลำดับต่อเนื่อง ของ CPU ได้อีกต่อไป และต้องเข้าใจโมเดลการประมวลผลแบบขนานขนาดใหญ่ของ GPU จึงจะจัดการประสิทธิภาพการเทรนและการอนุมานได้อย่างเหมาะสม
  • CPU สำหรับผู้ใช้ทั่วไปมักมี 2~16 คอร์ และเด่นด้านงานเธรดเดี่ยวกับการแตกแขนงตามเงื่อนไข ขณะที่ GPU มีคอร์ขนาดเล็กนับพัน จึงได้เปรียบในงานคำนวณเมทริกซ์ การประมวลผลภาพ และดีปเลิร์นนิง
  • AWS มี สภาพแวดล้อมสำหรับรัน GPU เช่น P3/P4, P5/Inf1, G4 และ Amazon SageMaker โดย p3.2xlarge อยู่ที่ $3.06 ต่อชั่วโมง, p5.48xlarge อยู่ที่ $98.32 และ g4dn.xlarge อยู่ที่ $0.526
  • CUDA ของ NVIDIA เปิดให้นักพัฒนาจัดการลำดับงานแบบขนานได้โดยตรง ตั้งแต่การจัดสรรหน่วยความจำบน GPU การคัดลอกข้อมูล การรันเคอร์เนล ไปจนถึงการคอมไพล์
  • ตัวอย่างการบวกอาร์เรย์ การสร้าง Mandelbrot และ CNN สำหรับแยกแมว·สุนัข แสดงให้เห็นวิธีแบ่งลูปแบบลำดับไปเป็นเธรดบน GPU โดย Mandelbrot ลดเวลาจาก 4.07 วินาทีบน CPU เหลือ 0.0046 วินาทีบน GPU

ทำไมความรู้เรื่อง CPU อย่างเดียวจึงไม่พอ

  • นักพัฒนาจำนวนมากคุ้นเคยกับการเรียนรู้และแก้ปัญหาแบบ ยึด CPU เป็นศูนย์กลาง แต่วิธีทำงานพื้นฐานของ CPU นั้นอาศัยสถาปัตยกรรมแบบลำดับต่อเนื่อง
  • CPU แบบดั้งเดิมรันคำสั่งเป็นเส้นตรง และปรับแต่งคอร์จำนวนน้อยแต่ทรงพลังให้เหมาะกับประสิทธิภาพแบบเธรดเดี่ยว
  • เมื่อจำเป็นต้องจัดการหลายงานพร้อมกัน ต้นทุนของการประมวลผลทีละงานจะเพิ่มสูงขึ้นเพราะแนวทางแบบลำดับต่อเนื่อง
  • แม้จะเพิ่มประสิทธิภาพได้ด้วยมัลติเธรด แต่ปรัชญาการออกแบบพื้นฐานของ CPU ก็ยังใกล้เคียงกับ การทำงานแบบลำดับต่อเนื่อง อยู่ดี

โมเดล AI กับการประมวลผลแบบขนาน

  • สถาปัตยกรรม AI สมัยใหม่อย่าง Transformer ใช้ การประมวลผลแบบขนาน เพื่อยกระดับประสิทธิภาพการเทรน
  • RNN ทำงานแบบลำดับ แต่ Transformer อย่าง GPT สามารถประมวลผลหลายคำพร้อมกันได้ จึงช่วยทั้งประสิทธิภาพการเทรนและความสามารถของโมเดล
  • การเทรนแบบขนานทำให้สร้างโมเดลที่ใหญ่ขึ้นได้ และโมเดลที่ใหญ่ขึ้นก็เป็นพื้นฐานให้สร้างผลลัพธ์ที่ดีกว่าเดิม
  • ความเป็นขนานไม่ได้ใช้แค่กับการประมวลผลภาษาธรรมชาติ แต่ใช้กับการรู้จำภาพได้ด้วย
    • AlexNet เป็นตัวอย่างของการประมวลผลหลายส่วนของภาพพร้อมกันเพื่อระบุแพตเทิร์น
  • CPU ซึ่งออกแบบโดยเน้นประสิทธิภาพเธรดเดี่ยว จึงกระจายและรันการคำนวณแบบขนานปริมาณมากที่โมเดล AI ซับซ้อนต้องการได้ไม่ดีนัก

วิธีที่ GPU ช่วยลดคอขวด

  • GPU ถูกออกแบบให้ใช้ คอร์ขนาดเล็กและเฉพาะทาง จำนวนมาก แทนคอร์ขนาดใหญ่และทรงพลังแบบ CPU
  • จุดเด่นของความขนานบน GPU จะชัดเจนมากในเวิร์กโหลดที่ต้องทำซ้ำการคำนวณชนิดเดียวกันจำนวนมาก เช่น การเรนเดอร์กราฟิกและการคำนวณทางคณิตศาสตร์ที่ซับซ้อน
  • เฟรมเวิร์กดีปเลิร์นนิงอย่าง TensorFlow ถูกปรับแต่งให้ใช้ประโยชน์จากประสิทธิภาพของ GPU เพื่อเร่งทั้งการเทรนและการอนุมาน
  • การเทรนโครงข่ายประสาทมี การคำนวณเมทริกซ์ จำนวนมาก และ GPU ก็เด่นด้านการทำงานเหล่านี้แบบขนานด้วยจำนวนคอร์ที่มาก

ความต่างของบทบาท CPU และ GPU

  • CPU

    • CPU ถูกออกแบบโดยเน้น การประมวลผลแบบลำดับต่อเนื่อง จึงเหมาะกับงานที่รันสายคำสั่งเดียวแบบเชิงเส้น
    • เหมาะกับงานคอมพิวติ้งทั่วไป งานระบบ และอัลกอริทึมซับซ้อนที่มีการแตกแขนงตามเงื่อนไข
    • CPU สำหรับผู้ใช้ทั่วไปมักมีคอร์ค่อนข้างน้อย อยู่ในช่วง 2~16 คอร์
    • แต่ละคอร์สามารถประมวลผลชุดคำสั่งของตัวเองได้อย่างอิสระ

  • GPU

    • GPU ถูกออกแบบเป็น สถาปัตยกรรมแบบขนาน จึงมีประสิทธิภาพในการจัดการงานย่อยจำนวนมากพร้อมกัน
    • เหมาะกับการเรนเดอร์กราฟิก การคำนวณทางคณิตศาสตร์ซับซ้อน และการรันอัลกอริทึมที่ทำให้ขนานได้
    • งานจะถูกแบ่งเป็นหน่วยขนานย่อยที่เล็กลงเพื่อให้หลายการคำนวณทำงานพร้อมกันได้
    • คอร์ของ GPU มักมีจำนวนถึงหลักพัน และประกอบเป็น streaming multiprocessors (SMs) หรือโครงสร้างที่คล้ายกัน
    • เหมาะกับงานที่ต้องจัดการข้อมูลจำนวนมากพร้อมกัน เช่น การประมวลผลภาพ·วิดีโอ ดีปเลิร์นนิง และการจำลองทางวิทยาศาสตร์

สภาพแวดล้อม GPU ที่เลือกใช้ได้บน AWS

  • AWS มี อินสแตนซ์ GPU หลายแบบสำหรับงานอย่างแมชชีนเลิร์นนิง

  • อินสแตนซ์ GPU อเนกประสงค์

    • P3 และ P4 เป็นอินสแตนซ์ GPU แบบอเนกประสงค์ เหมาะกับเวิร์กโหลดหลายประเภท
    • ใช้กับการเทรนและอนุมานของแมชชีนเลิร์นนิง การประมวลผลภาพ และการเข้ารหัสวิดีโอได้
    • p3.2xlarge มีราคา $3.06 ต่อชั่วโมง และให้ NVIDIA Tesla V100 GPU 1 ตัวพร้อมหน่วยความจำ GPU 16GB

  • อินสแตนซ์ที่เหมาะกับงานอนุมาน

    • การอนุมานคือกระบวนการนำข้อมูลแบบเรียลไทม์ใส่เข้าไปในโมเดล AI ที่ผ่านการเทรนแล้ว เพื่อทำนายหรือแก้ปัญหา
    • P5 และ Inf1 ถูกออกแบบมาสำหรับงานอนุมานของแมชชีนเลิร์นนิงที่ต้องการ latency ต่ำและความคุ้มค่าด้านต้นทุน
    • p5.48xlarge มีราคา $98.32 ต่อชั่วโมง และให้ NVIDIA H100 GPU 8 ตัว แต่ละตัวมีหน่วยความจำ 80GB รวมวิดีโอเมมโมรีทั้งหมด 640GB

  • อินสแตนซ์ที่เหมาะกับงานกราฟิก

    • G4 instances ถูกออกแบบมาเพื่อรองรับงานกราฟิกเข้มข้น
    • นักพัฒนาเกมสามารถใช้ G4 instances เพื่อเรนเดอร์กราฟิก 3D สำหรับเกมได้
    • g4dn.xlarge มีราคา $0.526 ต่อชั่วโมง และใช้ NVIDIA T4 GPU 1 ตัวพร้อมหน่วยความจำ 16GB

  • บริการแมชชีนเลิร์นนิงแบบจัดการให้

    • Amazon SageMaker เป็นบริการแบบ managed service สำหรับแมชชีนเลิร์นนิง ที่เปิดให้เข้าถึงอินสแตนซ์แบบใช้ GPU เช่น P3, P4 และ P5
    • SageMaker เหมาะกับองค์กรที่ต้องการเริ่มใช้งานแมชชีนเลิร์นนิงโดยไม่ต้องดูแลโครงสร้างพื้นฐานด้วยตนเอง
    • มีเอกสาร Amazon SageMaker ราคา แยกต่างหาก

การใช้งานพื้นฐานของ NVIDIA CUDA

  • CUDA คือแพลตฟอร์มคอมพิวติ้งแบบขนานและโมเดลการเขียนโปรแกรมที่ NVIDIA พัฒนาขึ้น เพื่อให้แอปพลิเคชันรันได้เร็วขึ้นด้วย GPU accelerator
  • ตัวอย่างแสดงลำดับงานพัฒนาแบบ CUDA ตั้งแต่การจัดสรรหน่วยความจำบน GPU การคัดลอกข้อมูล การรันเคอร์เนล ไปจนถึงการดึงผลลัพธ์กลับมา

  • ขั้นตอนการติดตั้ง

    • ดาวน์โหลด base installer และ driver installer จาก CUDA
    • เพิ่มตัวแปรสภาพแวดล้อมต่อไปนี้ใน .bashrc ของโฮมโฟลเดอร์
      • export PATH="/usr/local/cuda-12.3/bin:$PATH"
      • export LD_LIBRARY_PATH="/usr/local/cuda-12.3/lib64:$LD_LIBRARY_PATH"
    • รันคำสั่งต่อไปนี้
      • sudo apt-get install cuda-toolkit
      • sudo apt-get install nvidia-gds
    • รีบูตระบบเพื่อให้การเปลี่ยนแปลงมีผล

  • คำสั่งตรวจสอบที่มีประโยชน์

    • lspci | grep VGA: ระบุและแสดงรายการ GPU ในระบบ
    • nvidia-smi: แสดงข้อมูลละเอียดของ NVIDIA GPU เช่น อัตราการใช้งาน อุณหภูมิ และการใช้หน่วยความจำ
    • sudo lshw -C display: แสดงข้อมูล display controller เช่น การ์ดกราฟิก
    • inxi -G: แสดงข้อมูลกราฟิกซับซิสเต็ม รวมถึง GPU และจอแสดงผล
    • sudo hwinfo --gfxcard: ใช้ตรวจสอบข้อมูลละเอียดของการ์ดกราฟิกในระบบ

การทำให้การบวกอาร์เรย์เป็นงานขนานด้วย CUDA

  • การบวกอาร์เรย์เป็นปัญหาที่เหมาะสำหรับอธิบายการทำงานแบบขนานบน GPU
  • อาร์เรย์ตัวอย่างคือ A = [1,2,3,4,5,6], B = [7,8,9,10,11,12] และผลลัพธ์คือ C = [8,10,12,14,16,18]
  • วิธีแบบ CPU จะวนดูสมาชิกของอาร์เรย์ทีละตัวแล้วบวกกัน
  • เมื่อข้อมูลมีมากขึ้น เวลาของวิธีแบบลำดับจะเพิ่มขึ้น แต่ GPU สามารถคำนวณอย่าง 1+7, 2+8, 3+9 พร้อมกันได้
  • ตัวอย่าง CUDA ใช้ไฟล์เคอร์เนล .cu
    • __global__ หมายถึง ฟังก์ชันเคอร์เนล ที่ถูกเรียกใช้บน GPU
    • vectorAdd รับพอยน์เตอร์จำนวนเต็มสามตัวคือ a, b, c แล้วทำการบวกเวกเตอร์
    • threadIdx.x ใช้ดึงดัชนีของเธรดปัจจุบัน
    • แต่ละเธรดจะเก็บผลรวมของสมาชิกที่สอดคล้องกันไว้ใน c[i]
  • ฟังก์ชัน main จะดำเนินตามลำดับคือจัดสรรหน่วยความจำบน GPU คัดลอกข้อมูล รันเคอร์เนล แล้วคัดลอกผลลัพธ์กลับ
    • ใช้ cudaMalloc เพื่อจัดสรรหน่วยความจำ cudaA, cudaB, cudaC บน GPU
    • ใช้ cudaMemcpy เพื่อคัดลอก a, b จาก host ไปยัง GPU
    • รันเคอร์เนลด้วย vectorAdd <<<1, sizeof(a) / sizeof(a[0])>>>
    • คัดลอกเวกเตอร์ผลลัพธ์ cudaC จาก GPU กลับไปยัง host
  • การคอมไพล์และรันใช้คำสั่ง nvcc
  • มี โค้ดเต็ม ให้ดู

การใช้ GPU กับการสร้างภาพใน Python

  • การสร้าง Mandelbrot set คือการสร้างแพตเทิร์นภาพที่ซับซ้อนจากพฤติกรรมของตัวเลขในสมการหนึ่ง และเป็นงานที่ใช้ทรัพยากรสูง
  • ตัวอย่าง Python แบบใช้ CPU จะวนผ่านทุกพิกเซลเพื่อคำนวณค่า Mandelbrot และใช้เวลา 4.07 วินาที ในการสร้างภาพขนาด 1024×1536
  • เวอร์ชันเร่งความเร็วด้วย GPU ใช้ Numba library
    • ดีคอเรเตอร์ @jit ทำการคอมไพล์แบบ Just-In-Time เพื่อแปลงโค้ด Python เป็น machine code
    • ใช้ cuda.jit เพื่อสร้าง mandel_gpu และกำหนด device=True เพื่อให้รันบน GPU
    • mandel_kernel ทำงานบน CUDA GPU และกระจายงานสร้าง Mandelbrot ไปยังเธรดของ GPU
  • create_fractal_gpu ทำหน้าที่จัดสรรหน่วยความจำบน GPU ตั้งค่าเธรดและบล็อก รันเคอร์เนล ซิงโครไนซ์ และคัดลอกผลลัพธ์กลับ
    • ใช้ threadsperblock = (16, 16)
    • ใช้ cuda.synchronize() เพื่อรอให้งานบน GPU เสร็จสิ้น
    • ใช้ d_image.copy_to_host(image) เพื่อคัดลอกผลลัพธ์กลับมายังฝั่ง CPU
  • เวลาในการรันบน GPU อยู่ที่ 0.0046 วินาที ซึ่งเร็วกว่าโค้ดแบบ CPU มาก
  • มี โค้ดเต็ม ให้ดู

การเทรนโครงข่ายประสาทแยกแมว·สุนัขด้วย GPU

  • เพื่อแสดงให้เห็นว่า GPU ถูกใช้กับ AI อย่างไร จึงยกตัวอย่าง โครงข่ายประสาทที่แยกแมวและสุนัข
  • สิ่งที่ต้องเตรียมล่วงหน้าคือ CUDA และ TensorFlow
    • สามารถติดตั้ง TensorFlow ได้ด้วย pip install tensorflow[and-cuda]
    • ใช้ชุดข้อมูล Kaggle Dogs vs. Cats
    • หลังดาวน์โหลดแล้ว ให้จัดภาพแมวและสุนัขไว้ในโฟลเดอร์ย่อยคนละชุดภายในโฟลเดอร์สำหรับเทรน
  • โมเดลใช้โครงข่ายประสาทแบบคอนโวลูชัน (CNN)
    • pandas และ numpy ใช้สำหรับจัดการข้อมูล
    • Sequential ใช้สำหรับวางเลเยอร์ของโครงข่ายประสาทแบบเรียงตามลำดับ
    • Convolution2D, MaxPooling2D, Dense, Flatten เป็นเลเยอร์ที่ประกอบกันเป็น CNN
    • ImageDataGenerator ใช้สำหรับ data augmentation แบบเรียลไทม์ระหว่างการเทรน
  • ข้อมูลเทรนถูกโหลดด้วย ImageDataGenerator
    • ข้อมูลเทรนตั้งค่า rescale=1./255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True
    • ภาพอินพุตกำหนดขนาด (64, 64) ขนาดแบตช์ 32 และโหมดการจำแนกแบบไบนารี
  • โครงสร้าง CNN ประกอบด้วยคอนโวลูชัน แม็กซ์พูลลิง การ flatten เลเยอร์ Dense และเอาต์พุตแบบ sigmoid
  • โมเดลถูกคอมไพล์ด้วยออปติไมเซอร์ adam, loss แบบ binary_crossentropy และ metric แบบ accuracy
  • การเทรนรันด้วย epochs=25, validation_steps=2000 และบันทึกเป็นไฟล์ .h5 ด้วย classifier.save('trained_model.h5')
  • โค้ดสำหรับอนุมานจะโหลด trained_model.h5 แปลงภาพเป็นขนาด (64, 64) และถ้าค่าพยากรณ์มากกว่าหรือเท่ากับ 0.5 จะพิมพ์ dog ไม่เช่นนั้นจะพิมพ์ cat
  • มี โค้ดเต็ม ให้ดู

ขอบเขตของการใช้ GPU

  • ในยุค AI เป็นเรื่องยากที่จะมองข้ามความสามารถของ GPU และนักพัฒนาจำเป็นต้องเข้าใจศักยภาพของ GPU ให้ดียิ่งขึ้น
  • เมื่อขยับจากอัลกอริทึมแบบลำดับไปสู่อัลกอริทึมแบบ ขนาน GPU ก็กลายเป็นเครื่องมือสำหรับเร่งการคำนวณที่ซับซ้อน
  • ความสามารถในการประมวลผลแบบขนานของ GPU ได้เปรียบอย่างยิ่งกับงาน AI และแมชชีนเลิร์นนิงที่ต้องจัดการชุดข้อมูลขนาดใหญ่และสถาปัตยกรรมโครงข่ายประสาทที่ซับซ้อน
  • GPU ไม่ได้จำกัดอยู่แค่งานแมชชีนเลิร์นนิงแบบดั้งเดิม แต่ยังใช้กับงานวิจัยทางวิทยาศาสตร์ การจำลอง และงานที่ใช้ข้อมูลเข้มข้นได้ด้วย
  • พลังของการประมวลผลแบบขนานถูกนำไปใช้แก้ปัญหาในหลากหลายสาขา เช่น การค้นคว้ายาแบบใหม่ การสร้างแบบจำลองสภาพภูมิอากาศ และการจำลองทางการเงิน

บทความที่เกี่ยวข้อง

1 ความคิดเห็น

 
GN⁺ 2023-11-13
ความคิดเห็นจาก Hacker News

  • โค้ดในบทความนี้ผิด ไม่มีการเรียก CUDA kernel เลย: https://github.com/RijulTP/GPUToolkit/blob/f17fec12e008d0d37...
    90% ของเวลาที่ใช้ “คำนวณ” เซต Mandelbrot ด้วยโค้ดคอมไพล์แบบ JIT จริง ๆ แล้วไม่ได้ใช้กับการคำนวณ แต่ใช้กับการคอมไพล์ฟังก์ชัน
    ถ้าอยากเรียน CUDA ให้ถูกทาง การอิมพลีเมนต์การคูณเมทริกซ์ เป็นแบบฝึกที่ดี และมีทูทอเรียลที่น่าอ้างอิงคือ https://cnugteren.github.io/tutorial/pages/page1.html และ https://siboehm.com/articles/22/CUDA-MMM

    • ใน CUDA ยังมี SAXPY ซึ่งถูกเรียกว่าเป็น “Hello World” ของโค้ดคณิตศาสตร์แบบขนานด้วย SAXPY ย่อมาจาก “Single-Precision A·X Plus Y” เป็นฟังก์ชันมาตรฐานของ BLAS และเป็นการดำเนินการที่เรียบง่ายมากซึ่งรวมการคูณด้วยสเกลาร์กับการบวกเวกเตอร์เข้าด้วยกัน
      รับเวกเตอร์ทศนิยมลอยตัว 32 บิต X และ Y กับสเกลาร์ A แล้วคูณ X[i] แต่ละตัวด้วย A จากนั้นนำไปบวกกับ Y[i]: https://developer.nvidia.com/blog/six-ways-saxpy/
    • หลังจากถูกชี้ให้เห็น ก็แก้โค้ดและอัปเดตบล็อกแล้ว

  • แม้จะอ้างว่า “นักพัฒนาทุกคนควรรู้” แต่จริง ๆ แล้วดูใกล้เคียงกับบทความที่พูดถึง วิธีที่ GPU ถูกใช้ใน AI มากกว่า นักพัฒนาส่วนใหญ่ไม่ใช่นักพัฒนา AI และไม่ได้โต้ตอบกับ AI โดยตรงหรือใช้ GPU โดยตรงด้วย
    อีกทั้งแทบไม่พูดถึง กราฟิก 3D ซึ่งเป็นเหตุผลหลักที่ทำให้ GPU เกิดขึ้นมา

    • การรู้พื้นฐานของสาขาข้างเคียงมีประโยชน์ โดยเฉพาะถ้าเป็นสาขาที่ถูกนำไปใช้กว้างอย่าง machine learning ยิ่งเป็นเช่นนั้น และโปรเจกต์ที่ต้องรับผิดชอบเดือนหน้าอาจต้องใช้ machine learning ก็ได้ หรือเวลา collaborate กับเพื่อนร่วมงานที่รับผิดชอบส่วนนั้นก็ได้เปรียบ
      ถ้ามีความรู้พื้นฐาน ก็จะเข้าใจเรื่อง “AI” ที่ขายให้ผู้จัดการได้ดีขึ้นด้วย
      ท่าทีแบบ “ไม่จำเป็นต้องรู้สาขาข้างเคียง” เป็นสิ่งที่เห็นบ่อยในโรงเรียน ในสาย system administration เพื่อนร่วมรุ่นบอกว่าไม่ต้องรู้ programming ก็ได้ แต่สุดท้ายก็ต้องใช้ scripting ส่วนในโรงเรียนพัฒนาซอฟต์แวร์ก็บอกว่าไม่ต้องรู้ network ก็ได้ แต่ไม่กี่ปีต่อมา DevOps ก็ปรากฏทั่วไปในประกาศรับสมัครงาน
      ถ้าบทความยาวราว 1,500 คำ ต่อให้อ่านแบบตั้งใจศึกษาก็ใช้เวลาประมาณ 12 นาที และถ้าลองรันตัวอย่างโค้ดไปด้วยจนใช้สัก 2 ชั่วโมง ก็ยังไม่ใช่การลงทุนที่ใหญ่อะไร แน่นอนว่าต้องมีเงื่อนไขว่าบทความนั้นเป็นบทนำที่ดี
    • ตอนย้ายจากบริษัท embedded แบบดั้งเดิมไปสตาร์ทอัป จำได้ว่าเพื่อนร่วมงานแซวอย่างเป็นกันเองว่าผมไม่รู้วิธีส่ง JSON request ด้วย curl ตอนนี้ยังเป็นนักพัฒนา embedded อยู่ แต่หลังจากนั้นก็ได้เรียนรู้ backend, frontend และ infrastructure ไปมาก และดูเหมือนว่าในอีกไม่กี่ปีข้างหน้า สถานการณ์คล้าย ๆ กันนี้มีโอกาสเกิดขึ้นทั่วทั้งอุตสาหกรรมเกี่ยวกับ AI สูงมาก
    • แม้แต่ตัวอย่างการเรนเดอร์เซต Mandelbrot ก็ยังได้ความเร็วเพิ่มแค่ 10 เท่า ทั้งที่นี่เป็นตัวอย่างคลาสสิกของงานคำนวณที่แทบจะถูกจำกัดด้วยปริมาณการคำนวณทศนิยมลอยตัวล้วน ๆ ส่วนตัวมองว่าเป็นบทความที่แย่มาก
    • มีสมมติฐานที่ไม่ถูกต้องอยู่มาก เห็นด้วยว่านักพัฒนาส่วนใหญ่ไม่ใช่นักพัฒนา AI และผู้เขียนต้นฉบับดูเหมือนจะค่อนข้างห่างจากกลุ่มนักพัฒนาทั่วไป หรือไม่ก็เหมารวมทั้งหมดจากโลกแวดล้อมของตัวเอง
    • ทุกครั้งที่เห็นบทความที่อ้างว่า “นักพัฒนาทุกคนควรรู้” ข้ออ้างนั้นโดยมากมักไม่จริง อาจมีบทความที่มีข้อมูลซึ่งทุกคนควรรู้จริง ๆ อยู่บ้าง แต่ที่เจอส่วนใหญ่คือ clickbait

  • เหตุผลที่ Python ครองความนิยมใน AI น่าจะเป็นเพราะ ความสัมพันธ์ระหว่าง Python-C คล้ายกับ ความสัมพันธ์ระหว่าง CPU-GPU
    GPU มีประสิทธิภาพสูงมากแต่เขียนโค้ดโดยตรงยาก ผู้คนจึงใช้งาน GPU ผ่านการเรียก API ระดับสูงอย่าง PyTorch
    C ก็มีประสิทธิภาพดีแต่เขียนโค้ดยากเช่นกัน จึงใช้ Python เป็นชั้น abstraction เหนือ C
    ยังไม่ชัดว่าผู้คนจำเป็นต้องเข้าใจ GPU ลึกขนาดนั้นหรือไม่ โดยเฉพาะถ้าไม่ได้ลงลึกไปถึงการ train หรือ operate AI และเมื่อกฎของ Moore สิ้นสุดลงและ multithreading กลายเป็นวิธีหลักในการเพิ่มความเร็ว ก็มีโอกาสสูงที่จะเกิดภาษาใหม่ ๆ ที่ออกแบบให้เข้ากับ paradigm ของ parallel programming ดูเหมือนว่า Mojo จะเป็นจุดเริ่มต้นของเรื่องนี้

    • เคยสงสัยว่ามีที่ทางสำหรับ ภาษาใหม่ ที่เพิ่มประสิทธิภาพให้สูงสุดแบบมองไม่เห็น ไม่ว่าจะรันบนฮาร์ดแวร์ใดหรือไม่
      ตั้งแต่การคำนวณวนซ้ำแบบง่าย ๆ ไปจนถึงการออกแบบให้ทุกคำสั่งใช้ทุกคอร์ของ CPU แบบขนานอย่างชาญฉลาดอยู่เบื้องหลัง และส่งงานที่ทำได้ไปให้ GPU
      สงสัยว่ามีความพยายามแบบนี้แล้วหรือยัง หรือโดยพื้นฐานแล้วเป็นไปได้ไหม
    • กฎของ Moore ยังดูยากจะบอกว่าสิ้นสุดแล้ว และ multithreading ก็ไม่ใช่คำตอบเช่นกัน อย่างไรก็ตามประโยคแรกถูกต้อง
    • การเขียนโปรแกรม GPU ไม่ได้ยากขนาดนั้น CUDA ค่อนข้างตรงไปตรงมาสำหรับงานจำนวนมาก และบ่อยครั้งสามารถได้ความเร็วเพิ่ม 100 เท่าด้วยโค้ดไม่ถึง 100 บรรทัด
    • ถ้าใช้ภาษาที่ทันสมัยกว่า ก็สามารถรักษาความสามารถในการเขียนแบบ Python ไว้ได้ พร้อมกับได้ ประสิทธิภาพระดับ C ค่อนข้างง่ายด้วยซ้ำ กลับกัน ผมมองว่า C ขาด abstraction จนทำให้โค้ดที่ช้าแต่เรียบง่ายดูน่าดึงดูดกว่า
    • C คือวิถีชีวิต คนที่ใช้แทบแต่ C อย่างเดียวมักยอมรับแนวคิด “ช่องว่างที่มีความหมาย” ของ Python ได้ยาก

  • คำอธิบายว่า “เมื่อ CPU เจองานหลายอย่าง จะจัดสรรทรัพยากรให้ประมวลผลทีละงาน” นั้นเรียบง่ายเกินไป ถึงขั้นทำให้นึกอยากให้ CPU ยังเรียบง่ายได้ขนาดนั้นด้วยซ้ำ
    การที่บทความโฟกัสที่ programming model นั้นสมเหตุสมผล แต่จากมุมมองด้านประสิทธิภาพ คำพูดว่า “CPU รันคำสั่งแบบลำดับ” โดยพื้นฐานแล้วผิด pipeline รันคำสั่งแบบขนาน, มี SIMD และหลายคอร์ก็อาจร่วมกันประมวลผลปัญหาเดียวกันได้

    • บทความนี้ดูเหมือนจับประเด็นผิด CPU ที่มี AVX-512 ก็มี data parallelism ขนาดใหญ่ และ CPU เองก็สามารถรันคำสั่งจำนวนมากพร้อมกันได้เช่นกัน
      ความแตกต่างใหญ่คือ CPU ใช้ซิลิคอนและพลังงานจำนวนมากไปกับการจัดการ control flow เพื่อให้รันเธรดเดียวได้มีประสิทธิภาพ ในขณะที่ GPU ใช้ทรัพยากรนั้นกับหน่วยคำนวณจำนวนมากกว่า และรันเธรดจำนวนมหาศาลเพื่อซ่อน control flow และความหน่วงของหน่วยความจำ
    • CPU ก็รัน คำสั่ง SIMD หลายคำสั่งพร้อมกันเช่นกัน

  • คำพูดที่ว่า CPU เหมาะกับโค้ดแบบลำดับ ส่วน GPU เหมาะกับโค้ดแบบขนานนั้นถูกอยู่ระดับหนึ่ง แต่เป็นการประมาณแบบหยาบมาก หากสมมติงบพลังงานใกล้เคียงกันระดับหลายร้อยวัตต์ CPU จะมี “คอร์” ราว 100 คอร์ที่รันงานอิสระทีละงาน รวมถึงไฮเปอร์เธรด และซ่อนความหน่วงของหน่วยความจำด้วย branch prediction และ pipelining
    ส่วน GPU มี “หน่วยคำนวณ” ราว 100 หน่วย แต่ละหน่วยสลับรันงานอิสระประมาณ 80 งาน และซ่อนความหน่วงของหน่วยความจำด้วยการรันคำสั่งถัดไปของงานอื่น
    คำศัพท์ค่อนข้างชวนสับสน และมีความเป็นไปได้สูงว่า CPU จะมีเวกเตอร์ยูนิตกว้าง 256 บิต ส่วน GPU จะมีเวกเตอร์ยูนิตกว้าง 2048 บิต แต่ถ้าถอยออกมามอง ภาพรวมของสองสถาปัตยกรรมนี้ก็ดูคล้ายกันไม่น้อย

    • GPU มี แบนด์วิดท์หน่วยความจำ มากกว่า CPU ราว 10 เท่า และใน LLM ความต่างนี้สำคัญมาก เพราะหากทำ batch processing อย่างเหมาะสม การสร้างโทเค็นเอาต์พุตหนึ่งตัวแทบจะต้องอ่านหน่วยความจำทั้งหมด และหน่วยความจำนั้นก็ถูกใช้กับ weights หรือ KV cache
    • ผมสงสัยมาตลอดว่าทำไมไม่ค่อยมีความพยายามผสมคอร์ latency ต่ำจำนวนไม่กี่คอร์เข้ากับคอร์ throughput สูงจำนวนมาก เช่น เอา Intel P core หนึ่งคอร์ล้อมด้วย E core หลายคอร์ แล้วใส่ iGPU core หรือ AVX-512 unit จำนวนมากให้กับ E core เหล่านั้น
      ตั้งชื่อว่า Xeon Chi ก็น่าจะได้

  • ถ้ามองว่าภาษาโปรแกรมส่วนใหญ่ถูกออกแบบให้เหมาะกับการประมวลผลตามลำดับเหมือน CPU ขณะที่ Erlang/Elixir ถูกออกแบบให้เหมาะกับความขนานเหมือน GPU ก็สงสัยว่า Nx / Axon จะได้รับความนิยมหรือไม่: https://github.com/elixir-nx/

    • Erlang ไม่ได้ถูกออกแบบมาเพื่อการประมวลผลขนานที่ใช้การคำนวณหนัก ๆ แต่เพื่อ ระบบกระจาย ที่มี concurrency สูง
    • ผมอยากรู้จริง ๆ ว่า Elixir กับ Nx จะทำงานได้ดีแค่ไหนกับงานที่เน้นการคำนวณในคลัสเตอร์ HPC ในเชิงโครงสร้างแล้วไม่ได้ต่างจาก MPI ที่ใช้กันบ่อยในสาขานี้มากนัก และอาจเข้าถึงได้ง่ายกว่ามากเหมือน numpy กับ ecosystem ของ Python ด้านวิทยาศาสตร์
    • กำลังดูอยู่ว่าชุด Elixir กับ Nx/Axon จะเหมาะกับสถาปัตยกรรมอย่าง NVIDIA Grace Hopper ที่ผสม CPU กับ GPU หรือไม่
    • สงสัยว่ามันรันบน GPU หรือเปล่า ผมคิดว่าในอนาคตจำเป็นต้องมีทั้งสองแบบ การเขียนโปรแกรมแบบลำดับยังคงเป็น abstraction ที่ดีที่สุดสำหรับงานส่วนใหญ่ที่ไม่ต้องการการประมวลผลขนานมหาศาล

  • ต้องมีคู่มือซื้อ อยากรู้ว่าขั้นต่ำต้องจ่ายเท่าไร และตัวเลือกที่ดีที่สุดในแต่ละช่วงงบคืออะไร ปัญหาคือข้อมูลนั้นเปลี่ยนเป็นครั้งคราว และไม่รู้ว่ามีแหล่งข้อมูลที่คอยอัปเดตให้ทันสมัยอยู่หรือเปล่า

    • https://timdettmers.com/2023/01/30/which-gpu-for-deep-learni... โดยส่วนตัวถือว่าเป็นแหล่งข้อมูลที่ดีที่สุด
    • Google Colab, Kaggle Notebooks, Paperspace Notebooks ต่างก็ให้ ใช้ GPU ฟรี ภายใต้ข้อจำกัด ดังนั้นไม่จำเป็นต้องเสียเงินเพื่อเรียนรู้การเขียนโปรแกรม GPU
      https://colab.google/
      https://www.kaggle.com/docs/notebooks
      https://www.paperspace.com/gradient/free-gpu
    • ถ้าแค่เรียนพื้นฐานการเขียนโปรแกรม GPU GPU ในตัว ก็เพียงพอแล้ว แน่นอนว่าแอปพลิเคชันใช้งานจริงในงานอาชีพมีความหลากหลายมาก
    • ถ้ายังไม่อยากจ่าย 1,000–2,000 ดอลลาร์ตอนนี้ ก็สามารถ เช่าทรัพยากรคอมพิวต์ ออนไลน์ได้

  • นี่กลับมาเป็นบทความคลิกเบตแนว “สิ่งที่นักพัฒนาทุกคนควรรู้” อีกแล้วหรือ

    • บทความรูปแบบนั้นดูเหมือนจะถูก ChatGPT แทนที่ได้ แต่ถ้าเขียนดีจริง ๆ ก็มีคุณค่าพอสมควร
      ผมชอบงานที่เผชิญหน้ากับความซับซ้อนโดยตรง และมีความเข้าใจทั้งวิธีเชิงปริมาณและรายละเอียดเชิงคุณภาพในระดับหนึ่งของสาขาอย่างฮาร์ดแวร์คอมพิวเตอร์ ดังนั้นบทความที่อธิบายรายละเอียดของสาขาหนึ่งได้ดีจึงเป็นสิ่งที่น่ายินดี
      เช่น “What every programmer should know about memory” นั้นโปรแกรมเมอร์ทุกคนจำเป็นต้องรู้หรือไม่เป็นอีกเรื่อง แต่โปรแกรมเมอร์ที่ดีควรมีเซนส์ว่าคอมพิวเตอร์ทำงานจริงอย่างไร ประเด็นสำคัญที่ควรได้จากบทความนั้นคือ locality ซึ่งมักเกิดขึ้นเองในโค้ดที่ดีที่เร็ว ตามอ่านง่าย และเหมาะกับปัญหา
    • ดูเหมือนจะเป็นอย่างนั้น ข้ออ้างในบทความนี้ควรดูแบบ กลั่นกรอง

  • เป็นบทความที่ดี แต่ AWS P5 instance นั้นรวมถึง P4d, P4de ถูกวางมาเพื่อฝั่ง training อย่างชัดเจน ไม่ใช่ inference ประเภท instance ที่เหมาะกับ inference มากกว่าคือ G4dn และ G5 ซึ่งใช้ GPU T4 และ A10G ตามลำดับ

    • บทความต้นฉบับตก G5 ไป

  • ผมแทบไม่เคยเขียนโปรแกรม GPU มาก่อน แต่บทความนี้อ่านแล้วสนุก น่าทึ่งที่มันพัฒนามาถึงขั้นฝึก neural network แบบง่าย ๆ สำหรับแยก “หมาหรือแมว” ได้ง่ายขนาดนี้