Petals - รัน LLM ที่บ้านด้วยสไตล์ BitTorrent

 (petals.dev)
2 คะแนน โดย GN⁺ 2023-09-18 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • Petals ทำให้สามารถสร้างข้อความและทำ fine-tuning ได้โดยไม่ต้องโหลดโมเดลภาษาขนาดใหญ่ทั้งก้อนลงในอุปกรณ์เครื่องเดียว แต่รันเพียงบางส่วนด้วย GPU ตามบ้านหรือ Google Colab
  • รองรับ Llama 3.1 สูงสุด 405B, Mixtral 8x22B, Falcon 40B+, และ BLOOM 176B ทำให้สามารถใช้งานโมเดลขนาดใหญ่ได้แม้บนอุปกรณ์ส่วนบุคคล
  • ผู้ใช้จะโหลด ชิ้นส่วนของโมเดล ที่ตนรับผิดชอบ แล้วเชื่อมต่อกับเครือข่ายผู้เข้าร่วมที่ให้บริการชิ้นส่วนที่เหลือ ในโครงสร้างแบบ BitTorrent
  • ประสิทธิภาพการอนุมานแบบ single-batch อยู่ที่สูงสุด 6 tokens/sec บน Llama 2 70B และสูงสุด 4 tokens/sec บน Falcon 180B ซึ่งเพียงพอสำหรับแชตบอตและแอปแบบโต้ตอบ
  • สามารถเลือกวิธี fine-tuning และ sampling ได้กว้างกว่า LLM API ทั่วไป รวมถึงเข้าถึงเส้นทางภายในโมเดลและ hidden states ได้

รันโมเดลขนาดใหญ่แบบกระจายศูนย์

  • Petals มีเป้าหมายเพื่อให้รันโมเดลภาษาขนาดใหญ่ที่บ้านได้ โดยทำงานในลักษณะคล้าย BitTorrent ที่ผู้ใช้หลายคนช่วยกันให้บริการส่วนต่าง ๆ ของโมเดล
  • ผู้ใช้ไม่จำเป็นต้องโหลดทั้งโมเดล แต่เพียงอัปโหลด บางส่วนของโมเดล แล้วเข้าร่วม เครือข่าย ที่มีผู้ให้บริการส่วนที่เหลือ
  • โมเดลที่รองรับ:
    • Llama 3.1: สูงสุด 405B
    • Mixtral: 8x22B
    • Falcon: 40B+
    • BLOOM: 176B
  • สามารถทำ text generation และ fine-tuning เฉพาะงานได้ด้วย GPU ตามบ้านหรือ Google Colab
  • ประสิทธิภาพการอนุมานแบบ single-batch:
    • Llama 2 70B: สูงสุด 6 tokens/sec
    • Falcon 180B: สูงสุด 4 tokens/sec
  • ความเร็วระดับนี้เพียงพอสำหรับ แชตบอต และแอปแบบโต้ตอบ

ขอบเขตการควบคุมที่กว้างกว่า API

  • Petals ไปไกลกว่า LLM API แบบดั้งเดิม โดยเปิดให้เลือกวิธี fine-tuning และ sampling ได้โดยตรง
  • สามารถรัน custom paths ที่ผ่านภายในโมเดล หรือตรวจดู hidden states ได้
  • มอบทั้งความสะดวกแบบ API และความยืดหยุ่นของ PyTorch กับ 🤗 Transformers
  • มีทั้ง Colab notebook ที่ลองรันได้ทันที และ เอกสาร GitHub
  • มี วิธีเข้าร่วม เพื่อช่วยเพิ่มความจุให้ Petals ด้วยการให้ GPU และสามารถติดตามข่าวพัฒนาได้ทาง Discord
  • โปรเจกต์นี้เป็นส่วนหนึ่งของเวิร์กช็อปวิจัย BigScience

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

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

 
GN⁺ 2023-09-18
ความคิดเห็นบน Hacker News

  • น่าสนใจ ดูเหมือนเป็นโครงสร้างที่แบ่ง น้ำหนักของโมเดล ออกเป็นชั้น ๆ แล้วกระจายไปยังหลายเครื่อง แต่ละเครื่องเมื่อพร้อมก็ลงทะเบียนตัวเองในตารางแฮชขนาดใหญ่ จากนั้นทำ inference หรือ fine-tuning “เป็นทีม” สำหรับชั้นที่ตนรับผิดชอบ
    ยังอยู่ในช่วงแรก ๆ แต่ผมได้ทำงานเกี่ยวกับการโฮสต์น้ำหนักโมเดลสำหรับ https://github.com/jmorganca/ollama ไว้บน Docker registry เหตุผลหลักคือ content addressability ทำให้ Ollama ตรวจสอบได้ทุกครั้งว่าน้ำหนักที่ดาวน์โหลดมาถูกต้อง และท้ายที่สุดจะสามารถดึงน้ำหนักตามตัวคอนเทนต์เอง แทนที่จะอ้างอิงด้วยชื่อหรือ URL ที่อาจเปลี่ยนได้
    ขั้นต่อไปน่าจะเป็นการแบ่งโมเดลตามชั้นและจัดเก็บแต่ละชั้นอย่างอิสระ เพื่อนำไปใช้กับกรณีแบบนี้ หรือใช้ดาวน์โหลดและรันโมเดลที่ใหญ่ขึ้นบนเครื่อง “โลคัล” หลายเครื่องได้

    • ลดการโปรโมตตัวเองลงหน่อยได้ไหม ผมเห็นคอมเมนต์เกี่ยวกับ ollama บ่อยมากในทุกโพสต์ที่เกี่ยวกับ LLM
      แนวทางของ HN ก็ระบุไว้ว่า “อย่าใช้ HN เพื่อการโปรโมตเป็นหลัก การโพสต์งานของตัวเองเป็นครั้งคราวไม่เป็นไร แต่จุดประสงค์หลักในการใช้ไซต์ควรเป็นความอยากรู้อยากเห็น”
      ในกรณีนี้ แค่พูดถึงงานของ OP ก็พอแล้ว ไม่น่าจำเป็นต้องใส่แบ็กลิงก์ฟรีไปยังโปรเจกต์ด้วย

  • ตรงที่บอกว่า “สามารถ fine-tune ให้เหมาะกับงานได้” ทำให้ผมเลิกคิ้วเลย
    การ fine-tune โมเดล 70B ไม่ใช่แค่ยาก แต่ถ้าไม่เช่าอินสแตนซ์คลาวด์ราคาแพงมาก หรือซื้อพีซีระดับราคาบ้าน ต่อให้รอได้นานแค่ไหนก็เป็นไปไม่ได้จริง ๆ
    ถ้ามี “llama training horde” ผมยินดีเข้าร่วม

    • ถ้าเป็น fine-tuning แบบดั้งเดิมก็ถูก แต่ไม่แน่ใจว่าใช้กับ parameter-efficient fine-tuning หรือ qLORA ด้วยหรือเปล่า
      เท่าที่เข้าใจ โมเดลขนาด N หมื่นล้านพารามิเตอร์สามารถ fine-tune ได้ด้วย GPU ที่มี VRAM เป็นกิกะไบต์น้อยกว่า N เล็กน้อย
      ถ้าเป็นโมเดล 70B พารามิเตอร์ ก็น่าจะประมาณ A100 ไหม?
    • H100 น่าจะราคาใกล้รถยนต์มากกว่าบ้านนะ
    • ถ้า fine-tune แบบกระจายบนเครือข่ายที่เชื่อถือได้ยาก ประสิทธิภาพด้านพลังงานและต้นทุน อาจแย่กว่าโหนดเดียวหรือคลัสเตอร์ที่เชื่อมต่อกันดีมาก
      อีกอย่าง บน Lambda Cloud สามารถ fine-tune โมเดล 70B ได้ในราคา 2 ดอลลาร์ต่อหนึ่งล้านโทเค็น และบน Replicate ต่ำกว่า 10 ดอลลาร์
    • อะไรคือสิ่งที่ขวางไม่ให้ parallelize การฝึก LLM? ไม่ว่าจะอ่านหนังสือ 1 ก่อนแล้วค่อยอ่านหนังสือ 2 หรือกลับกัน ผลลัพธ์การอัปเดตความรู้ก็ควรเหมือนกัน
      ถ้ามองว่า LLM เรียนรู้หนังสือแต่ละเล่มอย่างอิสระ ก็ดูเหมือนว่าน่าจะแค่นำเดลตาสองชุดของน้ำหนัก LLM มาบวกกันได้
    • ถ้าใช้เทคโนโลยี compiler optimization ของ CentML จะสามารถ fine-tune 40B Falcon บน 4×A10 ได้โดยไม่ต้องเปลี่ยนโมเดล

  • LLM ที่ฝึกแล้วสามารถ ประกอบรวมกันได้ ในรูปแบบใดรูปแบบหนึ่งไหม? เช่น ถ้าทั้งสองเชื่อถือข้อมูลเหมือนกัน 99% แต่ต่างกันแค่ 1% จำเป็นต้องมีโมเดลแยกกันสองตัวเลยไหม หรือสามารถแชร์การคำนวณกับคนอื่นที่มีความเห็นเหมือนกันใน 99% แล้วสร้างโมเดลอนุพันธ์ที่ชดเชยความต่างของโมเดลความเชื่อถือของแต่ละคนได้ไหม?
    ผมเข้าใจโครงข่ายประสาทเทียมแค่ระดับพื้นฐาน แต่การปรับน้ำหนักในลักษณะนั้นโดยยังรักษาประโยชน์ใช้สอยของโมเดลไว้ ดูไม่ได้ไร้เหตุผลเสียทีเดียว
    เหตุผลที่ถามคือ ถ้าเรารู้ได้ว่า LLM สองตัวที่มีประสิทธิภาพเท่ากันเห็นด้วยกับประโยคใด และมี disagreement กับประโยคใด ก็น่าจะมีประโยชน์ จากนั้นอาจย้อนแมปความต่างนั้นกลับไปยังความต่างของข้อมูลฝึกได้ แม้คงเป็นไปได้เฉพาะเมื่อความต่างมีขนาดเล็กเท่านั้น
    ในทางกลับกัน ถ้า LLM สองตัวที่มีประสิทธิภาพเท่ากันถือเป็นการพลาดโอกาสสร้างโมเดลที่แข็งแกร่งกว่าหนึ่งตัว และการวิเคราะห์ disagreement ก็แพงเกินไป นั่นก็จะเป็นโลกที่ค่อนข้างต่างออกไป

    • ทำได้ในระดับหนึ่ง ดู LoRA: https://arxiv.org/abs/2106.09685
      ไม่ได้หมายถึง composability แบบที่เอาชั้นปรับแต่งเหล่านี้มาผสมกันตามใจได้ แต่การแชร์ฐานน้ำหนักร่วมกันแล้วฝึกโมเดลที่ต่างกันนั้นเป็นปัญหาที่แก้ได้แล้ว
    • สิ่งนี้เรียกว่า ensemble https://blog.allenai.org/llm-blender-a-simple-ensemble-learn...

  • จะป้องกันผู้เข้าร่วมที่มีเจตนาร้ายไม่ให้เปลี่ยนเอาต์พุตส่วนของตนในการคำนวณที่ใหญ่กว่าได้อย่างไร? แม้จะไม่มีวิธีสร้างเอาต์พุตของเครือข่ายตามที่ผู้โจมตีกำหนด แต่ถ้ามีโหนดจำนวนมากเข้ามาแล้วส่งผลลัพธ์ขยะกลับไปเฉย ๆ ก็ดูเหมือนจะทำให้ระบบถูก โจมตีแบบปฏิเสธการให้บริการ ได้โดยพฤตินัย

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

  • คำถามแรกที่ผุดขึ้นมาคือ “ความคุ้มค่าทางเศรษฐกิจเป็นอย่างไร?” ตาม FAQ ระบุว่า:
    แรงจูงใจของ Petals อิงกับคริปโตเคอร์เรนซี บล็อกเชน ฯลฯ หรือไม่? ไม่ใช่ แม้ Petals จะเป็นระบบแบบกระจายศูนย์อย่างสมบูรณ์ในทุกด้านอื่น ๆ แต่ระบบแรงจูงใจกำลังทำเป็นระบบรวมศูนย์ คล้ายกับ kudos ของ AI Horde ไม่มีแผนจะให้บริการแลกคะแนนเหล่านี้เป็นเงิน จึงมองได้ว่าเป็นคะแนน “เกม” ที่ใช้ภายในระบบ
    Petals เป็นโปรเจกต์ที่เน้นแมชชีนเลิร์นนิง สำหรับนักวิจัยและวิศวกรด้านแมชชีนเลิร์นนิง และไม่เกี่ยวข้องกับการเงิน เหตุผลที่เลือกระบบแรงจูงใจแบบรวมศูนย์คือพัฒนาและบำรุงรักษาได้ง่ายกว่ามาก ทำให้โฟกัสกับการพัฒนาฟีเจอร์ที่เป็นประโยชน์ต่อนักวิจัยแมชชีนเลิร์นนิงได้
    https://github.com/bigscience-workshop/petals/wiki/FAQ:-Freq...

    • AI Horde kudos ที่พูดถึงตรงนี้เจ๋งมากจริง ๆ และโดยส่วนตัวคิดว่าถูกใช้น้อยกว่าที่ควรอย่างมาก:
      https://lite.koboldai.net/
      https://tinybots.net/artbot
      https://aihorde.net/
      จริง ๆ แล้ว ถ้ามีใครใน HN อยากลองทดสอบโมเดล fine-tuned ขนาด 13B~70B ตัวใดตัวหนึ่ง ตอนบ่ายผมโฮสต์ให้ได้:
      https://huggingface.co/models?sort=modified&search=70B+gguf
    • ฝั่งกราฟิกดีไซน์มี เรนเดอร์ฟาร์มแบบกระจาย มานานแล้ว นอกจากงานจะได้ลำดับความสำคัญสูงขึ้นเมื่อมีคะแนนสูง ก็ไม่มีแรงจูงใจอื่นเป็นพิเศษ
      https://www.sheepit-renderfarm.com/home
    • ถ้าดูคำตอบของคำถาม “อะไรคือแรงจูงใจในการโฮสต์เลเยอร์ของโมเดลใน swarm สาธารณะ?” คนที่รัน inference และ fine-tuning เองจะได้ความเร็วเพิ่มขึ้นระดับหนึ่งหากโฮสต์บางส่วนของโมเดลไว้ในเครื่องตัวเอง อีกทั้งเหมือนกับผู้ใช้ BitTorrent ที่แชร์ข้อมูลที่ดาวน์โหลดมาแล้วเพื่อช่วยคนอื่น ก็อาจมีแรงจูงใจที่จะตอบแทนชุมชนที่ช่วยให้ตนรันโมเดลได้
      สิ่งนี้อาจไม่เพียงพอสำหรับทุกคน จึงกำลังนำ “bloom points” ซึ่งเป็นแรงจูงใจที่ชัดเจนสำหรับผู้ที่บริจาคเวลา GPU ให้ swarm สาธารณะเข้ามาใช้ เมื่อระบบพร้อมแล้ว เว็บไซต์จะแสดงผู้มีส่วนร่วมอันดับต้น ๆ และผู้ที่ได้รับคะแนนจะสามารถนำไปใช้กับ inference/fine-tuning โดยได้ลำดับความสำคัญสูงขึ้นหรือการรับประกันด้านความปลอดภัยที่เข้มแข็งขึ้น หรืออาจแลกเป็นรางวัลอื่นได้
      ถึงอย่างนั้นก็ดูเหมือนยังต้องการ โทเคนแบบรวมศูนย์ อยู่บ้าง
    • น่าเสียดายที่ตอนนี้โปรเจกต์แบบกระจายศูนย์ทุกอย่างต้องถูกนำไปเทียบกับคริปโตเคอร์เรนซี
    • ข้อสรุปเชิงตรรกะก็คือ สุดท้ายโมเดลต่าง ๆ น่าจะถูกเชื่อมกับ การชำระเงินด้วยคริปโตเคอร์เรนซี และตรงนี้ Lightning จะมีความสำคัญ
      เพิ่มเติมคือ ไม่ได้หมายความว่าควรเชื่อม “โทเคน” ของ Petals เข้ากับระบบชำระเงิน แต่หมายถึงโดยทั่วไปแล้ว การเรียกใช้งานคลัสเตอร์โมเดลแมชชีนเลิร์นนิง ไม่ว่าจะกระจายศูนย์หรือไม่ มีแนวโน้มสูงที่จะใช้การชำระเงินด้วยคริปโตเคอร์เรนซีซึ่งให้ทั้งการยืนยันตัวตนและวิธีชำระเงินพร้อมกัน
      Petals เป็นการใช้งานการประมวลผลแบบกระจายศูนย์เพื่อใช้โมเดลที่ดี และดูน่าจะมีคุณค่าในระยะยาว

  • อยากแชร์ 3080 Ti แต่พอลองรันคำสั่งในคู่มือเริ่มต้นแล้วเหมือนมีปัญหาเรื่องเวอร์ชัน dependency: https://github.com/bigscience-workshop/petals/wiki/Run-Petal...
    ImportError: cannot import name 'get_full_repo_name' from 'huggingface_hub' (~/.local/lib/python3.8/site-packages/huggingface_hub/__init__.py)

  • ดูเหมือนจะโฮสต์ swarm เซิร์ฟเวอร์ของตัวเองได้ [0]
    สงสัยว่าประสิทธิภาพการ fine-tuning ของคลัสเตอร์ Petals “แบบส่วนตัว” จะอยู่ประมาณไหน
    [0] https://github.com/bigscience-workshop/petals/wiki/Launch-yo...

    • ถ้ารันคลัสเตอร์ในสภาพแวดล้อมที่เชื่อถือได้ ผมคิดว่าใช้ Ray หรืออะไรทำนองนั้นน่าจะมีประสิทธิภาพกว่า

  • เจ๋งจริง ๆ หวังว่าสิ่งนี้จะช่วยให้นักพัฒนาหลักพันหลักล้านเข้าถึงสาขานี้ได้มากขึ้น

  • ผมคิดมาตลอดว่า crowdsourcing คืออนาคต ไม่ว่าจะเป็นข้อมูลหรือการประมวลผลก็เหมือนกัน
    จริง ๆ แล้ว “ทรัพยากร” มีอยู่แล้ว แค่เป็นปัญหาเรื่องการจัดวางเท่านั้น

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