การทำอนุมาน Llama2 ที่รวดเร็วและพกพาได้บนเอดจ์แบบต่างสถาปัตยกรรม

 (secondstate.io)
2 คะแนน โดย GN⁺ 2023-11-14 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • เพื่อลดภาระจาก dependency จำนวนมากและความยุ่งยากในการดีพลอยของสแตกอนุมานที่เน้น Python เป็นศูนย์กลาง จึงแพ็กเกจ แอป Llama2 แบบ Rust+Wasm เป็นไบนารีขนาด 2MB เพื่อให้รันได้บนอุปกรณ์หลายประเภท
  • การติดตั้งใช้งานอิงจาก llama.cpp ที่ปรับให้เหมาะกับ Wasm โดยใช้ไฟล์โมเดล GGUF พร้อมปลั๊กอิน GGML ของ WasmEdge และ WASI NN API เพื่อใช้การเร่งความเร็วฮาร์ดแวร์ในเครื่อง
  • ตัวอย่างใช้โมเดล Llama-2-7B-Chat GGUF แบบ quantization 5-bit และให้ประสิทธิภาพราว 25 tokens/s บน M2 MacBook รุ่นประหยัด และราว 50 tokens/s บน Nvidia A10G
  • รันไทม์ WasmEdge สามารถใช้ร่วมกับเครื่องมือคอนเทนเนอร์ได้ ทำให้ง่ายต่อการดีพลอยไบนารี Wasm เดียวกันไปยังอุปกรณ์เอดจ์, on-premises และคลาวด์
  • เครื่องมือ GGML พร้อมใช้งานแล้ว แต่ยังอยู่ในช่วงเริ่มต้น โดยยังต้องรองรับปลั๊กอินสำหรับฮาร์ดแวร์และ OS เพิ่มเติม การตั้งค่า llama.cpp เพิ่มเติม และการรองรับ WASI NN API สำหรับภาษาแบบ Wasm-compatible หลายภาษา

รันการอนุมาน Llama2 ด้วย Rust+Wasm

  • สแตก Rust+Wasm สามารถใช้เป็นทางเลือกแทน Python สำหรับงาน AI inference ได้
    • แอป Rust+Wasm อาจมีขนาดเล็กกว่า Python ถึง 1/100 และเร็วกว่า 100 เท่า พร้อมใช้การเร่งความเร็วฮาร์ดแวร์ได้ในหลายสภาพแวดล้อมด้วยไบนารีเดียวกันโดยไม่ต้องแก้โค้ด
  • Second State ได้สร้าง โปรแกรม Rust แบบเรียบง่ายที่รันการอนุมานโมเดล Llama2 ได้ด้วยความเร็วระดับเนทีฟ
    • แอปไบนารี ที่คอมไพล์เป็น Wasm มีขนาด 2MB
    • แอป Wasm นี้พกพาไปใช้งานบนอุปกรณ์ที่มีตัวเร่งฮาร์ดแวร์ต่างชนิดกันได้
    • รันไทม์ WasmEdge มอบสภาพแวดล้อมการรันที่ปลอดภัยในคลาวด์
    • WasmEdge สามารถ ใช้งานร่วมกับเครื่องมือคอนเทนเนอร์ เพื่อ orchestrate และรันแอปแบบพกพาบนอุปกรณ์หลายประเภทได้

บนพื้นฐานของ llama.cpp และ GGUF

  • งานนี้สร้างบนพื้นฐานของ llama.cpp ที่พัฒนาโดย Georgi Gerganov
  • มีการปรับโปรแกรม C++ เดิมให้รันบน Wasm ได้
  • ไฟล์โมเดลใช้ ฟอร์แมต GGUF

ขั้นตอนการรัน

  • ติดตั้ง WasmEdge และปลั๊กอิน GGML บนอุปกรณ์ Linux หรือ Mac
curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/… | bash -s -- --plugins wasmedge_rustls wasi_nn-ggml
  • ดาวน์โหลดแอป Wasm ที่ build ไว้ล่วงหน้า
curl -LO https://github.com/LlamaEdge/LlamaEdge/…
  • ตัวอย่างนี้ใช้ไฟล์ GGUF ของโมเดล Llama2 7B chat-tuned ที่ทำ quantization เป็น 5-bit weights
curl -LO https://huggingface.co/second-state/Llama-2-7B-Chat-GGUF/…
  • รันแอป Wasm สำหรับอนุมานด้วย WasmEdge และส่งโมเดล GGUF เข้าไป แล้วจะสามารถพิมพ์คำถามแบบโต้ตอบได้
wasmedge --dir .:. --nn-preload default:GGML:AUTO:Llama-2-7b-chat-hf-Q5_K_M.gguf llama-chat.wasm

การตั้งค่าโมเดลและตัวอย่างประสิทธิภาพ

  • llama-chat.wasm ใช้ตัวเลือกบรรทัดคำสั่งเพื่อกำหนดวิธีโต้ตอบกับโมเดล
    • --ctx-size: ขนาด prompt context, ค่าเริ่มต้น 512
    • --n-predict: จำนวนโทเคนที่จะทำนาย, ค่าเริ่มต้น 1024
    • --n-gpu-layers: จำนวนเลเยอร์ที่รันบน GPU, ค่าเริ่มต้น 100
    • --batch-size: ขนาดแบตช์สำหรับประมวลผลพรอมป์ต์, ค่าเริ่มต้น 512
    • --temp: sampling temperature, ค่าเริ่มต้น 0.8
    • --repeat-penalty: บทลงโทษสำหรับโทเคนที่ซ้ำ, ค่าเริ่มต้น 1.1
    • --prompt-template: รองรับ llama-2-chat, codellama-instruct, mistral-instruct-v0.1, chatml, deepseek-chat, deepseek-coder เป็นต้น
    • --log-stat: แสดงสถิติ
  • ตัวอย่างการรันที่กำหนด context length เป็น 2048, จำกัดคำตอบสูงสุด 512 โทเคน และเปิดการแสดงสถิติ มีดังนี้
wasmedge --dir .:. --nn-preload default:GGML:AUTO:Llama-2-7b-chat-hf-Q5_K_M.gguf llama-chat.wasm -c 2048 -n 512 --log-stat
  • บน M2 MacBook รุ่นประหยัด การตอบของ LLM จะสตรีมออกมาโดยค่าเริ่มต้น และสร้างได้ราว 25 tokens/s
    • ตัวอย่างล็อกแสดงว่าอิงตาม eval time ในการรัน 82 ครั้ง ทำได้ 25.64 tokens/s
    • kv self size แสดงเป็น 1024.00MB และ compute buffer total size แสดงเป็น 630.14MB
  • บนอุปกรณ์ Nvidia A10G รันได้ราว 50 tokens/s
    • ใช้การเร่งความเร็วด้วย CUDA GPU และ offload เลเยอร์ 35/35 ไปยัง GPU
    • การใช้ VRAM แสดงเป็นโมเดล 4474.93MB, context 1648.02MB รวม 6122.95MB
    • อิงตาม eval time ในการรัน 83 ครั้ง ทำได้ 50.55 tokens/s

เซิร์ฟเวอร์ API ที่เข้ากันได้กับ OpenAI และแอป LLM

  • ยังมี เซิร์ฟเวอร์ API ที่เข้ากันได้กับ OpenAI ซึ่งสร้างด้วย Rust และ WasmEdge ให้ใช้งานด้วย
  • เมื่อใช้เซิร์ฟเวอร์นี้ ก็สามารถสร้างเอเจนต์และแอป LLM ด้วยเครื่องมือสำหรับนักพัฒนาที่เข้ากันได้กับ OpenAI เช่น flows.network
  • คำอธิบายที่เกี่ยวข้องอยู่ใน Build a super lightweight AI agent

ข้อจำกัดของสแตกอนุมานแบบ Python

  • LLM อย่าง Llama2 มักถูกฝึกด้วยเฟรมเวิร์กที่อิง Python เช่น PyTorch, Tensorflow และ JAX
  • แต่ในแอปพลิเคชันด้านการอนุมานซึ่งคิดเป็นราว 95% ของงาน AI computing มองว่า Python เสียเปรียบ
  • แพ็กเกจ Python อาจทำให้การตั้งค่าและการใช้งานยุ่งยากขึ้นเพราะมี dependency ที่ซับซ้อน
  • Docker image ของ Python หรือ PyTorch มักมีขนาดหลาย GB หรืออาจถึงหลายสิบ GB ทำให้เป็นภาระมากขึ้นสำหรับงาน AI inference บนเซิร์ฟเวอร์หรืออุปกรณ์เอดจ์
  • Python ช้ากว่าภาษาคอมไพล์อย่าง C, C++ และ Rust มาก และอาจช้าสูงสุดถึง 35,000 เท่า
  • เวิร์กโหลดจริงส่วนใหญ่ถูกส่งต่อไปให้ shared library แบบเนทีฟที่อยู่ใต้ Python wrapper ทำงาน
    • โครงสร้างแบบนี้เหมาะกับเดโม แต่ถูกมองว่ายากต่อการปรับแก้ภายในให้ตรงกับความต้องการเฉพาะของธุรกิจ
  • การพึ่งพา native library จำนวนมากและการจัดการ dependency ที่ซับซ้อน ทำให้ความพกพาของโปรแกรม AI บน Python ที่ต้องใช้ความสามารถฮาร์ดแวร์เฉพาะของแต่ละอุปกรณ์ลดลง
  • ยังมีกรณีที่แพ็กเกจ Python ซึ่งใช้กันบ่อยใน toolchain ของ LLM ชนกันจากข้อกำหนดเวอร์ชันของ pydantic
    • llama-cpp-python ต้องการ pydantic 2.0.1 และไม่ทำงานบน <=2.0
    • fastapi และ chromadb ต้องการ pydantic 1.9.2 และไม่ทำงานบน >=2.0

ข้อดีของ Rust+Wasm

  • สแตก Rust+Wasm สามารถใช้เป็นโครงสร้างพื้นฐานคลาวด์คอมพิวติงแบบรวมศูนย์ที่ครอบคลุมทั้งอุปกรณ์, edge cloud, เซิร์ฟเวอร์ on-premises และ public cloud ได้
  • สำหรับแอปพลิเคชัน AI inference มันอาจเป็นทางเลือกสำคัญแทนสแตก Python

  • เบามาก

    • แอปสำหรับอนุมานมีขนาด 2MB รวม dependency ทั้งหมดแล้ว
    • น้อยกว่า 1% ของขนาดคอนเทนเนอร์ PyTorch ทั่วไป

  • รันได้เร็ว

    • ให้ความเร็วระดับเนทีฟ C/Rust ได้ตลอดทั้ง preprocessing, tensor computation และ postprocessing

  • พกพาได้

    • แอปพลิเคชัน Wasm bytecode เดียวกันสามารถรันได้บนแพลตฟอร์มคอมพิวติงหลัก ๆ
    • รองรับการเร่งความเร็วด้วยฮาร์ดแวร์ที่หลากหลายด้วย

  • ตั้งค่า พัฒนา และดีพลอยได้ง่าย

    • ลด dependency ที่ซับซ้อนลง
    • สามารถ build ไฟล์ Wasm เดียวด้วยเครื่องมือมาตรฐานจากโน้ตบุ๊ก แล้วนำไปดีพลอยในหลายสภาพแวดล้อมได้

  • ปลอดภัยและพร้อมสำหรับคลาวด์

    • รันไทม์ Wasm ถูกออกแบบมาเพื่อแยกโค้ดของผู้ใช้ที่ไม่น่าเชื่อถือออกจากกัน
    • สามารถจัดการด้วยเครื่องมือคอนเทนเนอร์และดีพลอยบนแพลตฟอร์ม cloud-native ได้

โครงสร้างของโปรแกรมอนุมาน Rust

  • โปรแกรมสาธิตการอนุมานเขียนด้วย Rust และคอมไพล์เป็น Wasm
  • ซอร์สโค้ด Rust ส่วนหลักมีเพียงประมาณ 40 บรรทัด
  • โปรแกรม Rust รับหน้าที่ดังนี้
    • จัดการอินพุตจากผู้ใช้
    • ติดตามประวัติการสนทนา
    • แปลงข้อความให้อยู่ในรูปแบบ Llama2 chat template
    • รันการอนุมานผ่าน WASI NN API
  • หากต้องการ build เอง ให้ติดตั้ง Rust compiler และ target สำหรับคอมไพล์ wasm32-wasi
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup target add wasm32-wasi
  • จากนั้นดาวน์โหลดซอร์สโปรเจกต์และ build ไฟล์ Wasm ด้วย cargo
git clone https://github.com/second-state/llama-utils
cd llama-utils/chat/
cargo build --target wasm32-wasi --release
cp target/wasm32-wasi/release/llama-chat.wasm .

การดีพลอยบนคลาวด์และเอดจ์

  • เมื่อมีไฟล์ Wasm bytecode แล้ว ก็สามารถดีพลอยไปยังอุปกรณ์ใดก็ได้ที่รองรับรันไทม์ WasmEdge
  • ปัจจุบันปลั๊กอิน GGML รองรับ generic Linux และ Ubuntu Linux
    • CPU แบบ x86 และ ARM
    • Nvidia GPU
    • Apple M1/M2/M3
  • ปลั๊กอิน WasmEdge GGML อาศัย llama.cpp เพื่อใช้ การเร่งความเร็วฮาร์ดแวร์ ของอุปกรณ์โดยอัตโนมัติ
    • หากมี Nvidia GPU ตัวติดตั้งจะติดตั้งปลั๊กอิน GGML ที่ปรับแต่งสำหรับ CUDA โดยอัตโนมัติ
    • ปลั๊กอิน GGML สำหรับ Mac OS ใช้ Metal API เพื่อรันเวิร์กโหลดการอนุมานบน neural processing engine ในตัวของ M1/M2/M3
    • รุ่น build สำหรับ Linux CPU ใช้ OpenBLAS เพื่อตรวจจับและใช้ความสามารถการประมวลผล CPU สมัยใหม่อย่าง AVX และ SIMD โดยอัตโนมัติ
  • แนวทางนี้มุ่งให้เกิดความพกพาข้ามแพลตฟอร์มและฮาร์ดแวร์ AI ที่หลากหลาย โดยไม่ต้องแลกกับประสิทธิภาพ

งานในอนาคต

  • เครื่องมือ WasmEdge GGML พร้อมใช้งานแล้วและมีลูกค้า cloud-native ใช้อยู่ แต่ยังอยู่ใน ช่วงเริ่มต้น
  • พื้นที่ที่สามารถร่วมพัฒนาได้มีดังนี้
    • เพิ่มปลั๊กอิน GGML สำหรับฮาร์ดแวร์และแพลตฟอร์ม OS ให้มากขึ้น
      • สนใจ TPU, ARM NPU และชิป AI เฉพาะทางบน Linux และ Windows
    • รองรับการตั้งค่า llama.cpp ให้มากขึ้น
      • ปัจจุบันสามารถส่งตัวเลือกการตั้งค่าบางส่วนจาก Wasm ไปยังปลั๊กอิน GGML ได้เท่านั้น
      • เป้าหมายคือรองรับตัวเลือกทั้งหมดที่ GGML มีให้
    • รองรับ WASI NN API จากภาษาแบบ Wasm-compatible อื่น ๆ
      • สนใจ Go, Zig, Kotlin, JavaScript, C และ C++

การรองรับโมเดลนอกเหนือจาก LLM

  • WasmEdge และ WASI NN ยังสามารถใช้สร้างแอปอนุมานที่อิงโมเดล AI ยอดนิยมอื่น ๆ นอกเหนือจาก LLM ในฐานะทางเลือกแทน Python ที่เบา เร็ว พกพาได้ และปลอดภัย
  • mediapipe-rs มอบ Rust+Wasm API สำหรับตระกูลโมเดล Tensorflow ของ Google mediapipe
  • WasmEdge YOLO เป็นโปรเจกต์ Rust+Wasm API สำหรับจัดการโมเดล PyTorch YOLOv8
  • WasmEdge ADAS demo เป็นตัวอย่างที่ใช้โมเดล Intel OpenVINO สำหรับทำ road segmentation ในรถยนต์ไร้คนขับ
  • WasmEdge Document AI มีแผนจะมอบ Rust+Wasm API สำหรับตระกูลโมเดล OCR และการประมวลผลเอกสาร
  • สามารถร่วมพูดคุยและมีส่วนร่วมกับ WasmEdge ได้ที่ WasmEdge Discord

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

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

 
GN⁺ 2023-11-14
ความคิดเห็นใน Hacker News

  • Rust กับ WASM นั้นดี แต่ถ้าดูโค้ดแล้วก็มีแค่สคริปต์บรรทัดคำสั่ง Rust พื้นฐาน 150 บรรทัด เท่านั้น
    งานหนักถูกจัดการด้วยบรรทัดเดียวที่ส่งโมเดลไปยังแบ็กเอนด์ WASI-NN และในที่นี้มี WasmEdge runtime เป็นผู้ให้มา
    แต่ WasmEdge เป็น C++ ไม่ใช่ Rust และในกรณีนี้แทบไม่มีประโยชน์จาก Rust เลย อีกทั้งแบ็กเอนด์ยังเรียกจากภาษาอื่นอย่าง Python ได้ด้วย

    • ประโยชน์ของ Rust ตรงนี้น่าจะเป็นเรื่อง การบันเดิลและการดีพลอย
      การแพ็ก Python กับ PyTorch ให้อยู่ในรูปแบบที่ผู้ใช้ปลายทางดับเบิลคลิกแล้วรันได้ ตอนนี้ก็ยังแทบจะยุ่งเหยิงอยู่ดี และแม้โค้ดประสิทธิภาพสูงจริง ๆ ของทั้งสองฝั่งจะเป็น C++ แต่ถ้าสามารถจบได้ด้วย ไฟล์ executable 2MB ไฟล์เดียว แทนที่จะต้องแจกจ่ายไฟล์มากกว่า 2GB กับไฟล์นับหมื่นเพียงเพื่อส่งคำสั่งไม่กี่คำสั่งไปยัง C++ นั้น ก็มีความหมายอยู่

  • เป็นงานที่ยอดเยี่ยมมาก อย่างไรก็ตาม คนที่อยากลองใช้ก็ยังต้องดาวน์โหลด ไฟล์ weights ขนาดใหญ่อยู่ดี
    โดยแก่นแล้วก็เหมือนทำ llama.cpp ที่พกพาได้สมบูรณ์และไม่มี dependency ให้เหลือ 2MB
    ถ้าเป็นนักพัฒนาแอป นี่อาจเป็นวิธีที่ง่ายที่สุดในการแพ็ก inference engine ไว้ในไฟล์ที่แจกจ่ายได้ ส่วน weights นั้นพกพาได้อยู่แล้วและค่อยดาวน์โหลดเมื่อต้องใช้ได้ ดังนั้นส่วนที่อยากตรึงไว้จริง ๆ คือ inference engine

    • น่าจะมีประโยชน์กว่าถ้าเขียนในหัวข้อว่า wasm ขนาด 2MB
      อย่างที่บอก weights มีขนาดใหญ่กลบตัวเลขนั้นไปมาก
    • ไฟล์ main ที่ llama.cpp build บนเครื่องผมมีขนาด 1.2MB
      ขนาด 2MB เองไม่ได้ดูน่าประทับใจเป็นพิเศษ จุดสำคัญคือการ target ไปที่ wasm แล้วทำให้พกพาได้มากขึ้น ไม่ใช่ว่ามันถูกบีบอัดมากกว่าเป็นพิเศษ

  • นี่สุดท้ายก็แค่ห่อ llama.cpp ไว้ไม่ใช่หรือ? พูดตรง ๆ คือค่อนข้างเบื่อโปรเจกต์ที่ห่อ x.cpp แล้ว
    ตลอด 6 เดือนที่ผ่านมา ผมพัฒนา เฟรมเวิร์กแมชชีนเลิร์นนิง Rust + WebGPU และก็เข้าใจได้อย่างรวดเร็วว่างานของ GG นั้นยอดเยี่ยมแค่ไหน
    ยังอยู่ช่วงเริ่มต้น แต่ดูได้ที่นี่:
    https://www.ratchet.sh/
    https://github.com/FL33TW00D/whisper-turbo

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

  • wasm-nn ที่สิ่งนี้พึ่งพาอยู่ หรือก็คือ https://github.com/WebAssembly/wasi-nn เป็นข้อเสนอที่ส่ง chunk ใด ๆ ไปยัง implementation ของ vendor ตัว API ก็แทบมีแค่ระดับตั้งค่า input, คำนวณ, ตั้งค่า output
    ดังนั้นมันไม่ portable เลย
    เหตุผลที่มันทำงานได้คืออาศัย abstraction ที่มี implement อยู่แล้วใน llama.cpp โค้ดที่ map โมเดล gguf ไปยัง target hardware หลายแบบนั้น ดูเหมือนว่า WasmEdge จะยกมาใช้ตรง ๆ ที่นี่: https://github.com/WasmEdge/WasmEdge/tree/master/plugins/was...
    ดังนั้นคำอธิบายทำนองว่า “นักพัฒนาสามารถใช้ binding เขียนแอปแมชชีนเลิร์นนิงด้วยภาษาระดับสูง แล้ว compile เป็น WebAssembly จากนั้นรันบน runtime ที่รองรับ wasi-nn อย่าง WasmEdge ได้” นั้นผิดโดยสิ้นเชิง ในความเป็นจริงทำแบบนั้นไม่ได้
    สิ่งนี้ ไม่ portable, ไม่ใช่ sandbox และไม่ใช่ hardware abstraction layer
    ต่อให้มีไบนารี wasm ก็จะรันได้ก็ต่อเมื่อเวอร์ชัน runtime ที่ใช้อยู่บังเอิญ implement แบ็กเอนด์ ggml เฉพาะที่ต้องการ และไม่มีข้อกำหนดว่าต้องทำเช่นนั้นเลย ดังนั้นโดยมากก็น่าจะไม่ใช่
    ต่อให้ทำได้ สุดท้ายก็เป็นการเรียกโค้ด ggml ของ llama.cpp อยู่ดี ดังนั้นความปลอดภัยขึ้นอยู่กับไลบรารีนั้นเท่านั้น
    บทความเน้น “ความพกพา” กับ “Rust” มากเกินไป แต่ในความเป็นจริงแทบไม่เห็นข้อดีของทั้งสองอย่าง
    สมมติว่ามี WASI runtime บนฮาร์ดแวร์ใหม่ จะรันโมเดลได้ไหม? มี GPU support ไหม? คำตอบจะกลายเป็น “ไปตรวจดูว่า llama.cpp บนแพลตฟอร์มนั้น compile พร้อม GPU support ได้หรือไม่, runtime ที่ใช้มีปลั๊กอิน ggml หรือไม่, และข้างใน vendor ggml เวอร์ชันที่เข้ากันไว้หรือไม่ ถ้าไม่ก็ไม่ได้”
    ถ้าอย่างนั้นจะใช้ WASI ไปเพื่ออะไรกัน?
    การรองรับ GPU ข้ามแพลตฟอร์มนั้นยากจริง แต่สิ่งนี้ดูค่อนข้างเหลวไหล
    ลองนึกภาพว่า WebGPU ทำงานแบบ “โยน chunk ไบนารีไปที่ GPU แล้วถ้าเป็น chunk ที่เข้ากับฮาร์ดแวร์ปัจจุบัน ก็อาจจะวาดอะไรบางอย่างให้ได้” นี่แหละคือโครงสร้างแบบนั้น

    • ขอบคุณสำหรับคำอธิบาย ผมสงสัยอยู่พอดีว่าใน WASM ไปเอา GPU support มาจากไหน
    • ช่วยอธิบายผลกระทบด้านความปลอดภัยให้ละเอียดขึ้นได้ไหม?

  • รันสิ่งนี้ แบบออฟไลน์บน iPhone ได้ไหม? ถ้าได้ก็อาจมีประโยชน์ตอนแคมป์ปิ้ง เพราะจะใช้ได้คล้ายการค้นหาอินเทอร์เน็ตพื้นฐานโดยไม่ขึ้นกับสัญญาณรับส่ง

    • รันได้บนอุปกรณ์หลายแบบที่ใช้ Linux, Mac, Windows รวมถึง Raspberry Pi และแล็ปท็อป/เซิร์ฟเวอร์ส่วนใหญ่
      แต่การโหลดตัวโมเดลเองก็ยังต้องใช้ หน่วยความจำหลาย GB
    • ผมลองรันโปรเจกต์นี้บน Pixel แล้ว ดูเหมือนว่าจะทำงานบน iPhone/iPad บางรุ่นได้ด้วย
      [0] https://github.com/mlc-ai/mlc-llm
    • สำหรับการใช้งานแบบนั้น การดาวน์โหลดสำเนา Wikipedia อาจดีกว่า มีประเด็นอย่าง entropy ด้วย
    • ผมทำแอป iOS เชิงพาณิชย์ที่ประสบความสำเร็จพอสมควรสำหรับการใช้งานแบบนั้น
      ตอนแรกทำด้วย ggml แล้วภายหลังพบ mlc-llm จึงพอร์ตไปใช้ฐานนั้น
      [0]: https://apps.apple.com/us/app/private-llm/id6448106860

  • แม้ในเชิงแนวทางน่าจะยังมีวิธีอื่น ๆ ออกมาอีกในการรันสถาปัตยกรรม Transformer บนเอดจ์ให้มีประสิทธิภาพและเร็วขึ้น แต่ ข้อกำหนดด้าน VRAM แก้ด้วย Rust ไม่ได้ จึงดูเหมือนกำลังเข้าใกล้ขีดจำกัด
    คอขวดหลักเวลานำโมเดลที่ใหญ่พอขึ้นไปรันก็คือส่วนนี้เอง
    อาจพูดได้ว่า “โมเดลเล็กกำลังดีขึ้นเรื่อย ๆ ดู Mistral กับ llama 2 สิ” แต่โมเดลเล็กเองก็กำลังเข้าใกล้ข้อจำกัดด้านความจุเช่นกัน ข้อมูลที่ใส่ลงไปในพารามิเตอร์ 7 พันล้านตัวได้นั้นมีขีดจำกัด
    แนวทาง AI แบบนี้ดูไม่น่าจะนำไปสู่ AGI ได้ รู้สึกว่าไม่มีประสิทธิภาพเกินไป

    • ผมมองว่ายังมีพื้นที่เหลืออยู่พอสมควร แม้กับโมเดลเล็ก เช่น การใช้ ระบบ MoE หรือการโหลด LoRA แบบไดนามิก

  • คำอธิบายที่ว่า “ปลั๊กอิน GGML สำหรับ Mac OS ใช้ Metal API เพื่อรันงานอนุมานบนเอนจินประมวลผลประสาทในตัวของ M1/M2/M3” ดูเหมือนจะไม่ถูกต้อง
    การที่ GGML ใช้ Metal API หมายความว่ารันบน GPU ของ M1/2/3 ไม่ได้หมายความว่ารันบน Neural Engine
    แน่นอนว่าแค่นั้นก็ดีแล้ว แต่ถ้าพูดให้เคร่งครัดก็คืออย่างนั้น

    • นี่ไม่ใช่การทักท้วงเล็กน้อยเลย ใน https://github.com/ggerganov/llama.cpp/discussions/336 มีการถกเถียงกันค่อนข้างกระจัดกระจายว่า การใช้ Neural Engine โดยตรงนอกเหนือจาก GPU นั้นมีคุณค่าตั้งแต่แรกหรือไม่

  • ไม่ชอบ การตลาดแบบคลิกเบต ที่พูดเหมือนว่าเพียงเพราะแรปเปอร์ที่หุ้มไลบรารีแกนกลางใช้ภาษาอื่น โปรเจกต์จึงลดขนาดลงเหลือ 1/100 หรือเพิ่มความเร็วได้ 100~35000 เท่าเมื่อเทียบกับทางเลือกอื่น
    ทั้งยังมองข้ามเครื่องมือและความเชี่ยวชาญของชุมชนที่สะสมอยู่รอบทางเลือกอื่น ๆ ไปโดยสิ้นเชิง
    ก่อนอื่น โปรเจกต์นี้อิงกับ llama.cpp[1] และงานหนักอย่างการโหลดไฟล์โมเดลขนาดหลาย GB ขึ้น GPU/CPU แล้วรันนั้น llama.cpp เป็นผู้จัดการ
    ความเร็วในการอนุมานไม่ได้ถูกจำกัดด้วยการเลือกแรปเปอร์ และก็มีแรปเปอร์ Go, Python, Node, Rust หรือจะใช้ llama.cpp โดยตรงก็ได้
    ขนาดไบนารีก็ไม่ได้สำคัญมากนัก เพราะไฟล์โมเดลที่ควอนไทซ์ทั่วไปอยู่ในช่วง 5GB~40GB และต้องใช้เครื่องที่มี GPU แรง ๆ หรือ RAM 16~64GB
    [1] https://github.com/ggerganov/llama.cpp

  • หากส่วนใหญ่ของขนาดสุดท้ายคือค่าน้ำหนักของโมเดลที่ผ่านการฝึกมาแล้ว จะลดขนาดลงได้ถึง หลายหลัก โดยไม่เสียความแม่นยำได้อย่างไร?

    • ผมคิดว่าการลดขนาดโดยไม่สูญเสียความแม่นยำนั้นทำได้ยาก อย่างไรก็ดี GGUF ที่ผ่านการควอนไทซ์นั้นยอดเยี่ยมมาก
      2MB ที่พูดถึงตรงนี้ดูเหมือนจะหมายถึง ขนาดโปรแกรม โดยไม่รวมโมเดล น่าจะเป็นการรัน llama.cpp ผ่านเซิร์ฟเวอร์ Rust ที่รัน wasm และ llama.cpp
      ผมชอบ llama.cpp/examples/server ตัวเล็ก ๆ และฝังมันไว้ใน FreeChat อยู่ แต่การมีตัวเลือกเครื่องมือเพิ่มขึ้นก็เป็นเรื่องดีเสมอ
      ตรวจดูแล้ว ไฟล์ปฏิบัติการ arm64/x86 ที่ผมฝังอยู่ตอนนี้มีขนาด 4.2MB ส่วน FreeChat มีขนาด 12.1MB แต่โมเดลพื้นฐานมีขนาดประมาณ 3GB เลยไม่ได้ใส่ใจกับส่วนต่าง 2MB มากนัก
      [0]: https://github.com/ggerganov/llama.cpp/tree/master/examples/...
    • ถ้าหมายถึงการลดขนาดของตัวโมเดลเอง หรือก็คือค่าน้ำหนักที่ผ่านการฝึกมาแล้ว ลงหลายหลักโดยไม่สูญเสียความแม่นยำ นั่นเป็นโจทย์ยากอีกเรื่องหนึ่ง
      บทความนี้พูดถึงการลด ขนาดแอปอนุมาน ลง 100 เท่า

  • ไม่เข้าใจว่าทำไมต้องใช้สิ่งนี้แทนการใช้ llama.cpp โดยตรง

    • คำใบ้: สกุลเงินของ เศรษฐกิจ Rewrite-it-in-Rust ไม่ใช่การรันอะไรบางอย่างได้จริง
    • โดยปกติ llama.cpp ต้องคอมไพล์แยกสำหรับแต่ละระบบปฏิบัติการและสถาปัตยกรรม เช่น Windows, macOS, Linux ทำให้ความสามารถในการพกพาต่ำ
      ในบทความยังอธิบายด้วยว่าใช้ประโยชน์จาก การเร่งความเร็วด้วยฮาร์ดแวร์ บนอุปกรณ์ที่มีตัวเร่งฮาร์ดแวร์ต่างชนิดกัน
      หมายความว่าโปรแกรมที่คอมไพล์เป็น wasm สามารถใช้ทรัพยากรฮาร์ดแวร์หลากหลายบนอุปกรณ์หลายแบบได้อย่างมีประสิทธิภาพ เช่น GPU หรือชิป AI เฉพาะทาง
      หากทำด้วย C++ โดยตรง เพื่อให้ได้ประสิทธิภาพใกล้เคียงกัน อาจต้องมีการปรับแต่งหรือเวอร์ชันแยกสำหรับฮาร์ดแวร์แต่ละชนิด