Train Your Own LLM From Scratch - เวิร์กช็อปลงมือฝึก LLM ด้วยตัวเองตั้งแต่เริ่มต้น

 (github.com/angelos-p)
1 คะแนน โดย GN⁺ 1 시간 전 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • Train Your Own LLM From Scratch คือ เวิร์กช็อปแบบลงมือปฏิบัติ ที่ให้คุณเขียนทุกชิ้นส่วนของไปป์ไลน์การฝึก GPT ด้วยตัวเอง เพื่อเข้าใจว่าแต่ละองค์ประกอบทำอะไรและทำไมจึงจำเป็น
  • เป้าหมายคือสร้าง ข้อความสไตล์ Shakespeare ด้วยโมเดล GPT ที่ฝึกตั้งแต่ศูนย์บนโน้ตบุ๊ก โดยย่อขนาดลงเป็นโมเดลประมาณ 10M พารามิเตอร์ เพื่อให้จบได้ภายในเวิร์กช็อปหนึ่งเซสชัน
  • ขณะที่ nanoGPT มีเป้าหมายเพื่อทำซ้ำ GPT-2 ขนาด 124M พารามิเตอร์ โปรเจกต์นี้ถูกออกแบบให้เหลือเฉพาะแกนสำคัญ เพื่อให้ฝึกบนโน้ตบุ๊กได้ภายใน ไม่เกิน 1 ชั่วโมง
  • องค์ประกอบที่ต้องเขียนเองได้แก่ Tokenizer, สถาปัตยกรรมโมเดล ที่อิง Transformer, ลูปการฝึก และการสร้างข้อความ โดยท้ายที่สุดคุณจะได้ลงมือทำ model.py, train.py, generate.py ให้เสร็จด้วยตัวเอง
  • ความรู้พื้นฐานที่ต้องมีเพียงแค่คุ้นเคยกับการ อ่านโค้ด Python ก็พอ ไม่จำเป็นต้องมีประสบการณ์ด้านแมชชีนเลิร์นนิง และต้องใช้ Python 3.12+
  • สภาพแวดล้อมที่รองรับคือโน้ตบุ๊กหรือเดสก์ท็อปบน Mac, Linux และ Windows โดยการฝึกจะเลือกใช้ MPS ของ Apple Silicon GPU, CUDA ของ NVIDIA GPU หรือ CPU โดยอัตโนมัติ
  • สำหรับการติดตั้งบนเครื่อง แนะนำให้ใช้ uv และรัน uv sync และหากไม่มีสภาพแวดล้อมในเครื่องก็สามารถอัปโหลดไฟล์ไปยัง Google Colab แล้วรัน !python train.py ได้
  • เวิร์กช็อปจะไล่เรียงเนื้อหาตั้งแต่โทเค็นไนเซอร์ระดับตัวอักษร, embedding, self-attention, LayerNorm, บล็อก MLP, ฟังก์ชัน loss, AdamW, gradient clipping, การทำ learning rate scheduling รวมถึง temperature และ top-k sampling
  • สถาปัตยกรรมพื้นฐานจะเปลี่ยนข้อความนำเข้าให้เป็น token ID ระดับตัวอักษร จากนั้นผ่าน token embedding และ positional embedding เข้าสู่ Transformer หลายบล็อก ก่อนจะส่งออก logits สำหรับความน่าจะเป็นของโทเค็นถัดไป
  • การตั้งค่าโมเดลที่ให้มาประกอบด้วย Tiny ประมาณ 0.5M พารามิเตอร์ ใช้เวลาราว 5 นาทีบน M3 Pro, Small ประมาณ 4M ใช้เวลาราว 20 นาที และค่าเริ่มต้น Medium ประมาณ 10M ใช้เวลาฝึกราว 45 นาที
  • ทุกการตั้งค่าใช้ การทำโทเค็นระดับตัวอักษร ที่ vocab_size=65 และ block_size=256 โดยปรับให้เหมาะกับชุดข้อมูลขนาดเล็กราว 1MB อย่าง Shakespeare
  • การทำโทเค็นแบบ BPE มีคลังคำขนาดใหญ่เหมือน 50,257 vocab ของ GPT-2 ทำให้ในชุดข้อมูลขนาดเล็ก token bigram ส่วนใหญ่พบได้น้อยเกินไปจนเรียนรู้แพตเทิร์นได้ยาก และเนื้อหายังอธิบายการเปลี่ยนไปใช้ BPE เมื่อใช้ชุดข้อมูลที่ใหญ่ขึ้น
  • แหล่งอ้างอิงสำคัญที่แนะนำคือ nanoGPT, build-nanogpt video lecture, Karpathy's microgpt, nanochat, Attention Is All You Need (2017), GPT-2 paper (2019), TinyStories paper

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

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

 
GN⁺ 1 시간 전
ความคิดเห็นจาก Hacker News

  • ถ้าเนื้อหานี้น่าสนใจ ขอแนะนำคอร์ส CS336 ของ Stanford อย่างมากด้วย เนื้อหาครอบคลุมหลักสูตรคล้ายกันแต่ลงลึกกว่ามาก และยังแนะนำทั้งสัญชาตญาณเชิงทฤษฎีอย่าง scaling laws รวมถึงมุมมองเชิงระบบอย่างการทำ kernel optimization/profiling
    แน่นอนว่าต้องทำการบ้านเองด้วย: https://cs336.stanford.edu/

    • ไม่รู้ว่าดูเลกเชอร์ได้จากที่ไหน เหมือนไม่เห็นตัวเลือกสำหรับเรียนแบบบรรยาย

  • ขอโปรโมตหน่อย มีชุด Jupyter notebook ที่อธิบายหลักการทำงานของแมชชีนเลิร์นนิงตั้งแต่พื้นฐาน
    https://github.com/nickyreinert/DeepLearning-with-PyTorch-fr...
    และแน่นอนว่ามีสอนวิธีสร้าง LLM ตั้งแต่ต้นด้วย
    https://github.com/nickyreinert/basic-llm-with-pytorch/blob/...

  • เพิ่งเริ่มดู repository/หนังสือ/คอร์สของ Sebastian Raschka ชื่อ Build a Large Language Model (From Scratch) พอดี การต้องเลือกว่าจะใช้สื่อการเรียนอะไรอาจเป็นปัญหาแบบน่ายินดีก็ได้
    [0] https://github.com/rasbt/LLMs-from-scratch
    [1] https://www.manning.com/books/build-a-large-language-model-f...
    [2] https://magazine.sebastianraschka.com/p/coding-llms-from-the...

    • ฉันอ่านหนังสือเล่มนั้นอย่างสนุกมาก เหมาะสำหรับคนที่อยากเข้าใจโครงสร้างภายในจริง ๆ และอยากเห็น ตัวอย่างการทำงาน ของการคำนวณทุกขั้นตอน

  • ทำแบบนี้มาตั้งแต่วันเกิดแล้ว เริ่มต้นยาก แต่ก็ดีขึ้นเรื่อย ๆ

    • จริง ๆ แล้วที่ฝึกมาส่วนใหญ่คือ physical models และ LLM ก็เหมือนเป็นส่วนที่พ่วงเข้าไป

  • เคยลองทำด้วย ULMFiT ตอนที่ fast.ai ยังถือว่าค่อนข้างใหม่ น่าจะเป็นช่วงที่ BERT ยังเป็น state of the art รุ่นล่าสุด และเป็นสถาปัตยกรรมที่ฝึกโมเดลฐานก่อนแล้วค่อยปรับเฉพาะทางด้วย head
    โมเดลฐานใช้ Wikipedia ทั้งชุด และเพิ่มทวีตอีกหลาย GB ที่รวบรวมไว้จาก firehose เข้าไปด้วย ตอนนั้นมีสิทธิ์ใช้แล็บที่มีเครื่องคอมสำหรับพัฒนาเกมอยู่ 20 เครื่อง น่าจะประมาณระดับ GTX 2080 ใช้เวลาฝึกหนึ่งรอบกับ Wikipedia ที่ tokenize แล้วประมาณครึ่งวัน เลยให้แต่ละเครื่องรันค่าตั้งต่างกันเพื่อ hyperparameter tuning แล้ววันถัดไปก็ใช้ผลลัพธ์ที่ดีที่สุดเป็นจุดเริ่มต้น เช้ามาทำงานแล้วได้เปิดดูผลลัพธ์ทุกวันเป็นอะไรที่สนุกมาก
    งานวิศวกรรมตอนนั้นทั้งแย่และเฉพาะหน้าแบบสุด ๆ แต่ก็ได้เรียนรู้อะไรมาก ผลลัพธ์ออกมาใช้ได้ประมาณหนึ่งและเอาไปทำ tweet classification แต่ก็ทำให้พอเห็นภาพว่าถ้าจะทำจริงจังต้องใช้พลัง GPU และต้องเจอปัญหาวิศวกรรมหนักแค่ไหน ตอนนั้นยังไม่เข้าใจศักยภาพของงานสร้างข้อความทั้งหมดนัก แต่ก็เคยลองให้มันสร้างทวีตเล่น ๆ แล้วนั่งหัวเราะอยู่นาน

  • อันนี้ดูแทบจะถอดความวิดีโอของ Andrej Karpathy อันนี้(https://youtu.be/kCc8FmEb1nY)ออกมาเป็นบทความเลยหรือเปล่า หรือฉันเข้าใจผิด?

    • ในหน้าเว็บมีอธิบายความสัมพันธ์กับ nanoGPT อยู่
      ประมาณว่า “nanoGPT ตั้งเป้าจำลอง GPT-2 (124 ล้านพารามิเตอร์) และครอบคลุมหลายอย่าง โปรเจกต์นี้ตัดให้เหลือเฉพาะแก่นสำคัญ และย่อขนาดเป็นโมเดลราว 10 ล้านพารามิเตอร์ที่ฝึกบนโน้ตบุ๊กได้ภายใน 1 ชั่วโมง…”
    • ใช่ คุณเข้าใจผิด

  • เพิ่มบริบทอีกนิด เขาเป็นหนึ่งใน นักพัฒนา MLX และเป็นนักวิจัยแมชชีนเลิร์นนิงที่เก่งมาก

    • อยากรู้แหล่งที่มา เพราะดูเหมือนข้อมูลนั้นจะไม่ถูกต้อง

  • เขียนไว้ว่าเป็น “เวิร์กช็อปลงมือทำเพื่อเขียนทุกชิ้นส่วนของ GPT training pipeline ด้วยตัวเอง และเข้าใจว่าแต่ละองค์ประกอบทำอะไรและทำไมถึงจำเป็น” แต่เห็นว่ามี dependency เป็น torch งั้นก็คงไม่ได้เขียน tensor กับ backprop เอง และถือว่าสิ่งพวกนั้นมีมาให้อยู่แล้ว ถึงอย่างนั้นยังจะเรียกว่า “ตั้งแต่ต้น” ได้ไหมก็ไม่แน่ใจ
    ฉันเคยทำอะไรคล้าย ๆ กันด้วย Rust และใช้ AI ช่วยบ้าง แต่จำกัดว่าห้ามพึ่ง dependency ใด ๆ ใช้ได้แค่ standard library ผลคือจำเป็นต้องทำอีกหลายอย่างเองมาก เช่น ออกแบบ tensor, แนวคิดเรื่อง kernel, ตัว optimizer แบบ gradient descent อย่างง่าย, ตัวแยกวิเคราะห์ JSON ที่เขียนเอง, abstraction สำหรับ data parallel บน CPU คล้าย rayon ฯลฯ พอทุกอย่างต่อเข้าด้วยกันแล้วรันได้ก็ค่อนข้างสนุก ถึงจะช้ามาก แต่ก็ใช้งานได้จริง

  • ไม่แน่ใจว่าการใช้ PyTorch ยังควรถูกเรียกว่า “ตั้งแต่ต้น” ได้หรือเปล่า ไม่ได้จะเถียงสุดโต่งว่าต้องหลีกเลี่ยงแม้แต่ standard library แต่พอถึงจุดที่ดึงไลบรารีที่เหมาะตรงงานมาใช้ ก็ไม่ค่อยรู้สึกว่าเป็น “ตั้งแต่ต้น” แล้ว

    • ก็มีเหตุผลนะ แต่สำหรับคนสายแมชชีนเลิร์นนิงส่วนใหญ่ PyTorch ก็คือ standard library โดยพฤตินัย

  • น่าจะเรียกว่า “ฝึก LM ตั้งแต่ต้น” มากกว่า ฉันสงสัยว่าจะมีเครื่องใหญ่พอให้เรียกว่า “Large” ได้จริงไหม

    • ถ้ามีบัตรเครดิตวงเงินทั่ว ๆ ไป ก็น่าจะเช่าทรัพยากรจากผู้ให้บริการ neocloud อย่าง HuggingFace หรือ Mistral Forge ได้สบาย
      ไม่ได้บอกว่าคุ้ม แต่ถ้าจะฝึกก็ไม่จำเป็นต้องซื้อ GPU เอง
    • แม้แต่ 3090 ใบเดียวก็ฝึกโมเดลขนาด 1.6 พันล้านพารามิเตอร์ได้ตั้งแต่ต้นจนจบ ถือว่าใหญ่พอสมควร
    • ฉันก็มี RAM ครึ่งเทราไบต์นะ! ถึงจะเป็น DDR4 แต่ก็ยังเป็น RAM อยู่ดี
      แถมยังมีโปรเซสเซอร์ 48 คอร์ด้วย! ถึงจะไม่รองรับ AVX512 แต่ก็ยังคำนวณได้
      น่าจะฝึก LLM ได้พอสมควร หรืออย่างน้อยครอบครัวฉันก็น่าจะฝึกได้... ลูกอาจต้องรับช่วงโปรเจกต์ต่อ
      พูดจริงจังคือ ฉันว่าคุณอาจพลาดประเด็นไป หรือไม่ก็กำลังจับผิดโดยไม่จำเป็น หรือไม่ก็แค่ผิดไปเลย เรื่องนี้คือการเรียนรู้แนวคิด ส่วนที่เหลือส่วนใหญ่เป็นเรื่องรอง
      ถ้าจะมองในแง่ว่าเป็นการจับผิดหรือผิดไปเลย งั้นเกณฑ์มาตรฐานที่มีการบันทึกไว้สำหรับคำว่า “large” ใน large language model คืออะไร? GPT-2 ทั้งในตอนนั้นและตอนนี้ก็ถูกเรียกว่า large language model และมันมี 1.5 พันล้านพารามิเตอร์ ทุกวันนี้ GPU สำหรับผู้บริโภคราคาราว 400 ดอลลาร์ก็น่าจะฝึกขนาดนั้นได้แล้ว