Mistral-finetune - ปรับจูนโมเดล Mistral แบบ fine-tuning

 (github.com/mistralai)
1 คะแนน โดย GN⁺ 2024-05-27 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • mistral-finetune คือโค้ดเบสขนาดเล็กสำหรับทำ fine-tuning โมเดล Mistral ให้มี ประสิทธิภาพด้านหน่วยความจำ และให้ผลลัพธ์ที่ดี โดยปัจจุบันรีโพซิทอรีนี้ถูกเก็บถาวรแล้วและไม่ได้รับการบำรุงรักษาเชิงรุกอีกต่อไป
  • วิธีฝึกอิงตาม LoRA ซึ่งตรึงค่าน้ำหนักส่วนใหญ่ไว้ และ ฝึกเพิ่มเพียง 1~2% ในรูปของการรบกวนเมทริกซ์อันดับต่ำ
  • เพื่อประสิทธิภาพสูงสุด แนะนำให้ใช้ A100 หรือ H100 GPU และโค้ดถูกปรับให้เหมาะกับการฝึกแบบหลาย GPU บนโหนดเดียว แต่โมเดลขนาดเล็กอย่าง 7B ก็สามารถใช้ GPU เดียวได้
  • โมเดลที่รองรับมี 7B, Mixtral 8x7B, Mixtral 8x22B, Mistral-Nemo 12B และ Mistral Large v2 123B Instruct โดย Mistral-Nemo และ Large v2 ต่างมีข้อจำกัดด้านความยาวลำดับและอัตราการเรียนรู้ตามลำดับ
  • ข้อมูลต้องอยู่ในรูปแบบ jsonl และเป็นไปตามสคีมาที่เข้มงวด โดยขั้นตอนตรวจสอบรูปแบบและ ประเมินเวลาเทรน ด้วย utils.validate_data ก่อนเริ่มฝึกถือว่าสำคัญมาก

สถานะและเป้าหมายของโปรเจกต์

  • รีโพซิทอรี mistral-finetune อยู่ในสถานะ Archived และไม่ได้รับการบำรุงรักษาเชิงรุกอีกต่อไป
  • หากมีความต้องการจากชุมชน หรือเห็นว่าสามารถเพิ่มคุณค่าให้ระบบนิเวศของการทำ fine-tuning ได้ ก็อาจมีไลบรารีใหม่หรืออัปเดตครั้งใหญ่ในอนาคต
  • เป้าหมายคือการมอบ จุดเริ่มต้นที่เรียบง่ายและมีแนวทางชัดเจน สำหรับการทำ fine-tuning โมเดล Mistral
  • โค้ดเบสนี้มีแนวทางค่อนข้างชัดเจนโดยเฉพาะเรื่องรูปแบบข้อมูล และไม่ได้ตั้งเป้าเป็นเครื่องมืออเนกประสงค์ที่ครอบคลุมหลายสถาปัตยกรรมโมเดลหรือฮาร์ดแวร์หลายประเภท
  • หากต้องการแนวทางที่ทั่วไปกว่า สามารถดูโปรเจกต์อย่าง torchtune ได้

วิธีทำ fine-tuning และคำแนะนำด้านฮาร์ดแวร์

  • mistral-finetune อิงตาม LoRA
    • ค่าน้ำหนักของโมเดลส่วนใหญ่จะถูกตรึงไว้
    • จะ ฝึกเพิ่มเพียง 1~2% ของค่าน้ำหนักเพิ่มเติมในรูปของการรบกวนเมทริกซ์อันดับต่ำ
  • เพื่อประสิทธิภาพสูงสุด แนะนำให้ใช้ A100 หรือ H100 GPU
  • โค้ดถูกปรับให้เหมาะกับสภาพแวดล้อมการฝึกแบบ หลาย GPU บนโหนดเดียว
  • โมเดลขนาดเล็กอย่าง 7B ใช้ GPU เดียวก็เพียงพอ

อัปเดตล่าสุดของโมเดลที่รองรับ

  • ตั้งแต่ 13 สิงหาคม 2024 Mistral Large v2 รองรับการใช้งานกับ mistral-finetune
    • ต้องดาวน์โหลดเช็กพอยต์ 123B Instruct และตั้งค่า model_id_or_path ให้ชี้ไปยังไดเรกทอรีเช็กพอยต์นั้น
    • เนื่องจากโมเดลมีขนาดใหญ่ จึงต้องใช้หน่วยความจำมากกว่ามากในการทำ fine-tuning
    • ขณะนี้ต้องตั้ง seq_len เป็น ไม่เกิน 8192
    • แนะนำให้ใช้อัตราการเรียนรู้ต่ำกว่าโมเดลอื่น โดยในกรณีส่วนใหญ่ lr=1e-6 น่าจะทำงานได้ดี
  • ตั้งแต่ 19 กรกฎาคม 2024 Mistral Nemo รองรับการใช้งานกับ mistral-finetune
    • ต้องดาวน์โหลดโมเดล 12B Base หรือ Instruct และตั้งค่า model_id_or_path ให้ชี้ไปยังไดเรกทอรีเช็กพอยต์
    • ต้องใช้ mistral-common เวอร์ชันที่รองรับ Tekkenizer โดยติดตั้งเวอร์ชัน >=1.3.1 ด้วย pip install --upgrade mistral-common
    • เนื่องจากขนาด vocabulary ใหญ่ขึ้น ความต้องการหน่วยความจำสูงสุดของ CE loss จึงเพิ่มขึ้น ทำให้ตอนนี้ต้องใช้หน่วยความจำมากขึ้น
    • ขณะนี้ต้องตั้ง seq_len เป็น ไม่เกิน 16384
    • แนะนำให้ใช้ไฮเปอร์พารามิเตอร์แบบเดียวกับ 7B v3

การติดตั้งและดาวน์โหลดโมเดล

  • ขั้นตอนเริ่มต้นประกอบด้วยการโคลนรีโพซิทอรีและติดตั้ง dependency
  • แนะนำให้ทำ fine-tuning กับโมเดล Mistral ทางการ และ README มีลิงก์ดาวน์โหลดกับ checksum ของโมเดลดังต่อไปนี้
  • 8x7B Base V1 และ 8x7B Instruct V1 ต้องใช้ v3 tokenizer และขยาย vocabulary เป็น 32768 ก่อนทำ fine-tuning
  • ต้องระบุพาธโฟลเดอร์ของโมเดลที่ดาวน์โหลดมาเป็นพาธแบบสัมบูรณ์ใน model_id_or_path ของ YAML สำหรับการฝึก

ข้อกำหนดรูปแบบข้อมูล

  • ไฟล์ข้อมูลทั้งหมดต้องอยู่ในรูปแบบ jsonl
  • ข้อมูล pretraining จะเก็บข้อความธรรมดาไว้ในคีย์ "text"
  • ข้อมูล instruction จะเก็บรายการบทสนทนาไว้ในคีย์ "messages"
    • แต่ละรายการต้องมีคีย์ "content" และ "role"
    • "role" ต้องเป็นหนึ่งใน "user", "assistant", "system"
    • จะคำนวณ loss เฉพาะเมื่อ "role" == "assistant"
    • สามารถระบุ "weight": 0 ในข้อความ assistant เพื่อยกเว้นข้อความนั้นออกจากการฝึกได้
  • ข้อมูล function calling ก็เก็บรายการบทสนทนาไว้ในคีย์ "messages"
    • แต่ละรายการต้องมีคีย์ "role" และ "content" หรือ "tool_calls"
    • "role" ต้องเป็นหนึ่งใน "user", "assistant", "system", "tool"
    • จะคำนวณ loss เฉพาะเมื่อ "role" == "assistant"
    • "id" ของ "tool_calls" และ "tool_call_id" ต้องเป็นสตริงสุ่มความยาว 9 ตัวอักษรพอดี
    • README แนะนำให้สร้างค่าเหล่านี้อัตโนมัติในสคริปต์เตรียมข้อมูล

การตรวจสอบข้อมูลและเวิร์กโฟลว์ตัวอย่าง

  • ก่อนเริ่มฝึก ควรใช้ utils.validate_data เพื่อตรวจสอบรูปแบบข้อมูลและประเมินเวลาเทรน
  • ตัวอย่าง instruction ใช้บางส่วนของ Ultachat_200k
    • โหลดข้อมูล parquet ด้วย Pandas
    • แบ่งเป็น train 95% และ eval 5%
    • บันทึกเป็น jsonl
    • ระบุพาธใน data.instruct_data และ data.eval_instruct_data ของ example/7B.yaml
  • ระหว่างการตรวจสอบอาจพบปัญหาที่บางบทสนทนาจบด้วยบทบาท user
    • เนื่องจากฝึกเฉพาะข้อความ assistant ข้อความ user สุดท้ายจึงเป็นรายการที่ไม่จำเป็นต้องประมวลผล
    • สามารถแก้ข้อมูลได้ด้วย utils.reformat_data.py
  • หลังแก้ไขแล้ว เมื่อตรวจสอบอีกครั้งจะมีการแสดงสรุป เช่น จำนวนโทเคนของข้อมูล จำนวนโทเคนที่ใช้ฝึก จำนวน epoch, max_steps และเวลาโดยประมาณ
  • ในตัวอย่าง README ค่า max_steps=500 จะวนผ่านชุดข้อมูลประมาณ 5 รอบ และใช้เวลาประมาณ 30 นาทีบนคลัสเตอร์ 8xH100 โดยแนะนำให้ตั้ง max_steps=300

ตัวอย่างการทำ fine-tuning สำหรับ function calling

  • ตัวอย่าง function calling ใช้ Glaive function calling dataset
  • โหลดข้อมูลด้วย Pandas แล้วแบ่งเป็น train 95% และ eval 5% ก่อนบันทึกเป็น jsonl
  • ชุดข้อมูลต้นฉบับไม่ได้อยู่ในรูปแบบ function calling ที่ต้องการ จึงต้องรีฟอร์แมต
    • ต้องเปลี่ยน "from" เป็น "user"
    • ต้องลบอักขระ "\n" ที่ไม่จำเป็นออก
  • หากใช้ utils.reformat_data_glaive.py จะช่วยแปลงตัวอย่างส่วนใหญ่ให้อยู่ในรูปแบบที่ถูกต้องได้
  • เนื่องจากเป็นไปไม่ได้ที่จะเขียนสคริปต์รีฟอร์แมตชุดเดียวให้ใช้ได้กับทุกชุดข้อมูล จึงอาจต้องมีสคริปต์รีฟอร์แมตแยกสำหรับชุดข้อมูลที่ไม่เป็นไปตามรูปแบบที่กำหนด
  • ใช้ utils.validate_data --create_corrected เพื่อลบข้อผิดพลาดที่เหลือและสร้างชุดข้อมูล .corrected

การรันเทรนและตัวอย่างผลลัพธ์

  • หลังตรวจสอบข้อมูลแล้ว สามารถเริ่มฝึกได้
  • เพื่อให้ฝึกได้เร็วขึ้น แนะนำให้ตั้ง max_steps เป็น 300
  • ต้องตั้ง run_dir เป็นโฟลเดอร์สำหรับการทดลอง และสามารถระบุ wandb.project เพิ่มเติมเพื่อใช้การล็อกของ Weights & Biases ได้
  • การรันเทรนใช้ torchrun โดยต้องตั้ง --nproc-per-node ให้เท่ากับจำนวน GPU ที่ใช้งานได้
  • การฝึก UltraChat ใช้เวลาประมาณ 30 นาที บนโหนด 8xH100 และค่าน้ำหนักที่ได้อาจทำคะแนน MT Bench ได้ราว 6.3
  • การฝึก Glaive ใช้เวลาประมาณ 1 ชั่วโมง บนโหนด 8xH100 และมีการระบุว่าค่าน้ำหนักที่ได้ทำงานกับ function calling ได้ดี

รายการหลักของการตั้งค่าฝึก

  • model_id_or_path: โมเดล pretrain หรือพาธไดเรกทอรีโมเดลในเครื่องที่จะใช้เริ่มการฝึก
  • run_dir: ไดเรกทอรีสำหรับเก็บเช็กพอยต์และเมตริก
  • seq_len: ความยาวลำดับสำหรับการฝึก โดยตัวอย่างจะถูกแพ็กให้พอดีกับความยาว seq_len เพื่อประสิทธิภาพ
  • batch_size: จำนวนตัวอย่างฝึกต่อ GPU
    • ขนาดแบตช์โทเคนที่มีผลจริงทั้งหมดคือ num_gpus x batch_size x seq_len
  • max_steps: จำนวนรอบการฝึกทั้งหมด
    • จำนวนโทเคนรวมที่เห็นระหว่างการฝึกคือ max_steps x num_gpus x batch_size x seq_len
  • optim.lr: อัตราการเรียนรู้เริ่มต้นของ optimizer
  • optim.weight_decay: weight decay โดย README แนะนำให้ คงไว้ที่ 0.1
  • optim.pct_start: สัดส่วนของช่วง warm-up ใน PyTorch OneCycleLR
  • lora.rank: ขนาดของ LoRA adapter โดยแนะนำ ไม่เกิน 64
  • seed: ค่า seed ของตัวเลขสุ่มเพื่อให้การเริ่มต้น การสลับลำดับข้อมูล และการสุ่มตัวอย่างทำซ้ำได้
  • data.instruct_data: พาธข้อมูลฝึกแบบ instruction
    • ระบุได้ทั้งไฟล์ jsonl เดี่ยว, ไดเรกทอรี jsonl หรือหลายแหล่งข้อมูลที่มีการถ่วงน้ำหนัก
  • data.data: พาธข้อมูล pretraining เพิ่มเติมแบบเลือกใช้
  • data.eval_instruct_data: พาธข้อมูล instruction สำหรับประเมินแบบเลือกใช้
  • eval_freq, no_eval, ckpt_freq: ใช้ควบคุมรอบการประเมิน การประเมินระหว่างทาง และการบันทึกเช็กพอยต์
  • save_adapters: กำหนดว่าจะบันทึกเฉพาะ LoRA checkpoint หรือจะรวม LoRA เข้ากับโมเดลฐานแล้วบันทึกเป็นโมเดลเต็ม
    • save_adapters=False ต้องการหน่วยความจำ CPU และ GPU เพียงพอสำหรับการบันทึกโมเดลเต็มในโปรเซสเดียว ซึ่งโดยทั่วไปทำได้กับโมเดล 7B เท่านั้น

การอนุมานผลและ Weights & Biases

  • แนะนำให้ใช้ mistral-inference สำหรับการอนุมานผลจากโมเดลที่ฝึกแล้ว
  • ติดตั้งได้ด้วย pip install mistral_inference
  • เมื่อรัน mistral-chat สามารถใช้ค่าน้ำหนัก LoRA ได้โดยระบุพาธ lora.safetensors ที่บันทึกไว้ใน --lora_path
  • มีการรองรับ Weights and Biases เพื่อมอนิเตอร์เมตริกและการทดลองระหว่างฝึก
    • ติดตั้งด้วย pip install wandb
    • แนะนำให้ส่ง API key ผ่านตัวแปรสภาพแวดล้อม WANDB_API_KEY
    • ด้วยเหตุผลด้านความปลอดภัย จะไม่อ่าน API key จากการตั้งค่า YAML
    • loss ระหว่างฝึก, eval loss, learning rate และค่าอื่น ๆ จะถูกบันทึกและแสดงผลในแดชบอร์ดโปรเจกต์ wandb
  • วิธีใช้งานเพิ่มเติมดูได้จาก Weights and Biases documentation

การขยายโมเดลและ FAQ

  • สามารถทำ fine-tuning ได้เฉพาะโมเดล Mistral ที่เข้ากันได้กับ v3 tokenizer เท่านั้น
  • โมเดลที่รองรับต้องมีขนาด vocabulary เป็น 32768 ไม่ใช่ 32000
  • โมเดลรุ่นเก่าที่มี vocabulary 32000 สามารถขยายเป็น 32768 ได้ด้วย utils.extend_model_vocab
  • การทำ fine-tuning โมเดล MoE มีความแปรปรวนของประสิทธิภาพสูงกว่า
    • มีการแนะนำให้รัน fine-tuning แบบ MoE เดิมหลายครั้งด้วย seed ที่ต่างกัน แล้วเลือกผลลัพธ์ที่มีประสิทธิภาพดีที่สุด
    • ไม่พบความแปรปรวนสูงแบบนี้ในโมเดล dense
  • สามารถตรวจสอบจำนวนโทเคนที่ใช้ฝึกได้โดยป้อนไฟล์ YAML สำหรับการฝึกให้กับ utils.validate_data.py
  • หากเกิดข้อผิดพลาด CUDA out-of-memory สามารถลดขนาดแบตช์ต่อ GPU ได้
    • ขนาดแบตช์คือ seq_len x batch_size
    • มีการแนะนำให้ตั้ง batch_size เป็น 1 และลด seq_len
  • ไลบรารีนี้เผยแพร่ภายใต้ Apache 2.0 License
  • ห้ามใช้ไลบรารีนี้หรือโมเดลในลักษณะที่ละเมิด ใช้ประโยชน์จาก หรือฝ่าฝืนสิทธิใด ๆ รวมถึงทรัพย์สินทางปัญญาของบุคคลที่สาม

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

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

 
GN⁺ 2024-05-27
ความคิดเห็นบน Hacker News

  • ในเมื่อโมเดลพัฒนาเร็วขนาดนี้ การ fine-tune ยังมีคุณค่าอยู่ไหม? อยากรู้กรณีใช้งานจริง
    ตัวอย่างเช่น Bloomberg เคยฝึก LLM ระดับ GPT-3.5 ด้วยข้อมูลการเงินเมื่อปีที่แล้ว แต่ไม่นานหลังจากนั้น GPT-4-8k ก็ทำผลงานเหนือกว่าแทบทุกงานด้านการเงิน
    สุดท้ายเราจึงหันไปโฟกัสที่ ข้อมูลประเมินผล คุณภาพสูง และสถาปัตยกรรมที่ทำให้สลับไปใช้โมเดลใหม่ได้ง่าย

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

  • ถ้าจะทำสิ่งนี้ต้องใช้ GPU แบบไหน? มีแล็ปท็อป 3060 Ti, i9, RAM 16GB
    ไม่มีโควตา AWS หรือ GCP และเคยได้ยินเรื่อง Paperspace อยู่บ้าง แต่ในโปรเจกต์ลูกค้าที่กำลังทำอยู่มีแผนจะใช้โมเดล Mistral บางส่วน เลยอยากเริ่ม fine-tune Mistral ให้เร็วที่สุด

    • ถ้างบไม่ได้เป็น 0 จริง ๆ ขอแนะนำอย่างยิ่งให้ไปทาง เดสก์ท็อปเกมมิง
      GPU เกมมิงสามารถปล่อยความร้อน 300W ได้สบาย ๆ แต่ถ้า GPU แล็ปท็อปทำแบบนั้นคงละลาย และน่าจะถูกจำกัดไว้ราว ๆ 100W
      การระบายความร้อนแปรผันโดยตรงกับความเร็ว
      นอกจากนี้เดสก์ท็อปยังอัปเกรดเป็น GPU ที่เร็วขึ้นหรือใช้หลาย GPU ได้ด้วย
      แต่โดยเฉพาะการจัดชุดหลาย GPU นั้นเสียงดังและปล่อยความร้อนมากพอจะทำให้ห้องหนึ่งร้อนขึ้นได้อย่างรวดเร็ว
      ถ้าในอีกไม่กี่ปีข้างหน้าคุณไม่ได้รัน GPU แบบเต็มโหลดเกิน 10% ของเวลา คลาวด์ก็น่าจะถูกกว่า
    • ลองดูเว็บนี้ได้: https://www.hardware-corner.net/llm-database/Mistral/
      เขารวบรวม ข้อกำหนดฮาร์ดแวร์ ตามแต่ละโมเดลไว้ และสามารถเลือก VRAM กับหน่วยความจำระบบเพื่อกรองโมเดลที่ใช้งานได้
    • ใช้ เซิร์ฟเวอร์ GPU ที่ Hetzner ราคาเดือนละ 184 ยูโรได้
      บริษัทของเรา fine-tune Mistral และ Llama 3 ด้วย RTX4000 ที่นั่นมาแล้ว
      ค่อนข้างมีข้อจำกัดเล็กน้อยเพราะมี RAM แค่ 20GB แต่สำหรับจำนวนโทเค็นอินพุตที่มากขึ้น การลดระดับการทำ quantization ก็ช่วยได้
      ตอนนี้มีให้เช่าเป็นรายชั่วโมงด้วย
    • ลองใช้ openpipe ดูก็ดี
      ตอนนี้บริษัทใช้อยู่ และได้ผลลัพธ์ค่อนข้างดี

  • น่าสนใจมากว่าในแต่ละกรณีใช้งาน LLM ที่พบบ่อย เครื่องมือไหนจะกลายเป็น มาตรฐานโดยพฤตินัย
    อีโคซิสเต็มแตกกระจายมากจนรู้สึกว่าเครื่องมือส่วนใหญ่ไม่เคยได้ยินชื่อด้วยซ้ำ
    ไม่กี่วันก่อนเห็น Olive ของ Microsoft ซึ่งเป็นเครื่องมือที่เพิ่งเจอเป็นครั้งแรกเลย

  • ตอนนี้ LLM โอเพนซอร์สจำนวนมากอยู่ในระดับ “ใช้งานได้” แล้ว สิ่งสำคัญคือทำให้การพัฒนารอบ ๆ มันง่ายขึ้น
    โดยเฉพาะคนที่เป็นทั้งผู้ใช้และนักพัฒนาควรสามารถใช้ ข้อมูลส่วนตัว/ไม่เปิดเผย หรือพูดให้ชัดคือข้อมูลที่ไม่ได้อยู่ในการ pretraining ของโมเดลได้
    ใน repository ระบุว่าเหมาะกับโมเดลขนาดใหญ่และต้องใช้ A100/H100 แต่ถึงอย่างนั้นก็รู้สึกว่าสิ่งนี้อาจช่วยโมเดลขนาดเล็กได้มากกว่าโมเดลขนาดใหญ่
    สามารถขยายแนวคิด “ถ้าสร้างไว้ เดี๋ยวคนก็มา” ไปเป็น “ถ้ามีเครื่องมือให้ เดี๋ยวคนก็สร้าง” ได้

    • “ถ้ามีเครื่องมือให้ เดี๋ยวคนก็สร้าง” จะเป็นจริงก็ต่อเมื่อแรงจูงใจในการเรียนรู้เทคโนโลยีนั้นทำให้คาดหวังผลประโยชน์ในอนาคตได้เท่านั้น

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

  • จะปรับแต่งให้ฝึกโมเดลตัวแปรที่ใหญ่ขึ้นด้วย 3090 หรือ 4090 สองใบได้ไหม?

    • น่าจะเป็นไปได้ แม้ต้องลงแรงค่อนข้างมาก
      จุดเริ่มต้นที่พูดถึงตัวเลือกบางอย่างอยู่ที่นี่: https://huggingface.co/blog/trl-peft

  • จะฝึก โมเดลแชต WhatsApp ของฉันได้อย่างไร?

    • ต้องอธิบายให้ชัดกว่านี้ว่าหมายถึงอะไร
      อยากฝึกโมเดลด้วยข้อความ WhatsApp ของตัวเองหรือ? จุดประสงค์คืออะไร? ขึ้นอยู่กับว่าต้องการให้มันเขียนเหมือนตัวเอง หรืออยากทำถามตอบแบบ RAG