หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>โค้ดแหล่งที่มา AI
ดาวน์โหลด

webllm

เอ็นจิ้นการอนุมาน LLM ในเบราว์เซอร์ประสิทธิภาพสูง

เอกสาร BlogPost | กระดาษ | ตัวอย่าง

ภาพรวม

WebLLM เป็นเอ็นจิ้นการอนุมาน LLM ที่มีประสิทธิภาพสูงซึ่งนำการอนุมานแบบจำลองภาษาลงบนเว็บเบราว์เซอร์โดยตรงด้วยการเร่งความเร็วฮาร์ดแวร์ ทุกอย่างทำงานภายในเบราว์เซอร์โดยไม่มีการรองรับเซิร์ฟเวอร์และเร่งด้วย WebGPU

WebLlm เข้ากันได้อย่างสมบูรณ์กับ OpenAI API นั่นคือคุณสามารถใช้ OpenAI API เดียวกันกับ โมเดลโอเพนซอร์ซใด ๆ ในเครื่องด้วยฟังก์ชันการทำงานรวมถึงสตรีมมิ่ง, โหมด JSON, การเรียกใช้ฟังก์ชัน (WIP) ฯลฯ

เราสามารถนำโอกาสที่สนุกสนานมากมายในการสร้างผู้ช่วย AI สำหรับทุกคนและเปิดใช้งานความเป็นส่วนตัวในขณะที่เพลิดเพลินกับการเร่งความเร็วของ GPU

คุณสามารถใช้ WebLLM เป็นแพ็คเกจ NPM พื้นฐานและสร้างเว็บแอปพลิเคชันของคุณเองได้โดยทำตามตัวอย่างด้านล่าง โครงการนี้เป็นโครงการสหายของ MLC LLM ซึ่งช่วยให้การปรับใช้ LLM เป็นสากลในสภาพแวดล้อมฮาร์ดแวร์

ลองดู WebLlm Chat เพื่อลอง!

คุณสมบัติที่สำคัญ

  • การอนุมานในเบราว์เซอร์ : WEBLLM เป็นเอ็นจิ้นการอนุมานแบบจำลองภาษาที่มีประสิทธิภาพสูงในเบราว์เซอร์ที่ใช้ประโยชน์จาก WebGPU สำหรับการเร่งความเร็วฮาร์ดแวร์ทำให้สามารถใช้งาน LLM ที่ทรงพลังได้โดยตรงภายในเว็บเบราว์เซอร์โดยไม่ต้องประมวลผลฝั่งเซิร์ฟเวอร์

  • ความเข้ากันได้ของ OpenAI API เต็มรูปแบบ : รวมแอปของคุณเข้ากับ WebLLM ได้อย่างราบรื่นโดยใช้ OpenAI API กับฟังก์ชันการทำงานเช่นสตรีมมิ่ง, โหมด JSON, การควบคุมระดับ logit, การเพาะและอื่น ๆ

  • การสร้าง JSON ที่มีโครงสร้าง : WebLLM รองรับการสร้างโครงสร้าง JSON ที่ทันสมัยซึ่งนำมาใช้ในส่วน webAssembly ของไลบรารีโมเดลเพื่อประสิทธิภาพที่ดีที่สุด ตรวจสอบสนามเด็กเล่น WebLlm JSON บน HuggingFace เพื่อลองสร้างเอาต์พุต JSON ด้วย Schema JSON ที่กำหนดเอง

  • การสนับสนุนแบบจำลองที่กว้างขวาง : WebLlm สนับสนุนแบบจำลองต่าง ๆ รวมถึง Llama 3, Phi 3, Gemma, Mistral, Qwen (通义千问) และอื่น ๆ อีกมากมายทำให้มันมีความหลากหลายสำหรับงาน AI ต่างๆ สำหรับรายการรุ่นที่รองรับที่สมบูรณ์ให้ตรวจสอบโมเดล MLC

  • การรวมโมเดลที่กำหนดเอง : รวมและปรับใช้โมเดลที่กำหนดเองในรูปแบบ MLC ได้อย่างง่ายดายช่วยให้คุณสามารถปรับ WebLLM ให้สอดคล้องกับความต้องการและสถานการณ์ที่เฉพาะเจาะจงเพิ่มความยืดหยุ่นในการปรับใช้แบบจำลอง

  • การรวมปลั๊กแอนด์เพลย์ : รวม WebLLM เข้ากับโครงการของคุณได้อย่างง่ายดายโดยใช้ผู้จัดการแพ็คเกจเช่น NPM และเส้นด้ายโดยตรงหรือผ่าน CDN โดยตรงพร้อมตัวอย่างที่ครอบคลุมและการออกแบบแบบแยกส่วนสำหรับการเชื่อมต่อกับส่วนประกอบ UI

  • การโต้ตอบสตรีมมิ่งและเรียลไทม์ : รองรับการสตรีมการแชทที่สมบูรณ์ช่วยให้การสร้างเอาต์พุตแบบเรียลไทม์ซึ่งช่วยเพิ่มแอปพลิเคชันแบบโต้ตอบเช่นแชทบอทและผู้ช่วยเสมือน

  • การสนับสนุนผู้ปฏิบัติงานและบริการผู้ปฏิบัติงาน : เพิ่มประสิทธิภาพ UI และจัดการวงจรชีวิตของรุ่นได้อย่างมีประสิทธิภาพโดยการปิดการคำนวณเพื่อแยกเธรดของคนงานหรือพนักงานบริการ

  • การสนับสนุนส่วนขยายของ Chrome : ขยายฟังก์ชันการทำงานของเว็บเบราว์เซอร์ผ่านส่วนขยาย Chrome ที่กำหนดเองโดยใช้ WebLLM พร้อมตัวอย่างที่มีอยู่สำหรับการสร้างส่วนขยายพื้นฐานและขั้นสูง

โมเดลในตัว

ตรวจสอบรายการที่สมบูรณ์ของรุ่นที่มีอยู่ในรุ่น MLC WebLlm รองรับชุดย่อยของรุ่นที่มีอยู่เหล่านี้และสามารถเข้าถึงรายการได้ที่ prebuiltAppConfig.model_list

นี่คือครอบครัวหลักของแบบจำลองที่ได้รับการสนับสนุนในปัจจุบัน:

  • LLAMA : Llama 3, Llama 2, Hermes-2-Pro-llama-3
  • พี : พี 3, พี 2, พี 1.5
  • Gemma : Gemma-2b
  • MISTRAL : MISTRAL-7B-V0.3, HERMES-2-PRO-Mistral-7B, Neuralhermes-2.5-mistral-7b, OpenHermes-2.5-mistral-7b
  • Qwen (通义千问) : QWEN2 0.5B, 1.5B, 7B

หากคุณต้องการรุ่นเพิ่มเติมขอรูปแบบใหม่ผ่านการเปิดปัญหาหรือตรวจสอบโมเดลที่กำหนดเองสำหรับวิธีการรวบรวมและใช้โมเดลของคุณเองด้วย webllm

Jumpstart พร้อมตัวอย่าง

เรียนรู้วิธีใช้ WebLLM เพื่อรวมโมเดลภาษาขนาดใหญ่เข้ากับแอปพลิเคชันของคุณและสร้างการแชทให้เสร็จผ่านตัวอย่างแชทบ็อตง่าย ๆ นี้:

สำหรับตัวอย่างขั้นสูงของโครงการที่มีขนาดใหญ่และซับซ้อนกว่านั้นให้ตรวจสอบการแชทของ WebLlm

ตัวอย่างเพิ่มเติมสำหรับกรณีการใช้งานที่แตกต่างกันมีอยู่ในโฟลเดอร์ตัวอย่าง

เริ่มต้นใช้งาน

WebLLM เสนออินเทอร์เฟซแบบมินิมัลลิสต์และโมดูลาร์เพื่อเข้าถึง chatbot ในเบราว์เซอร์ แพ็คเกจได้รับการออกแบบในแบบแยกส่วนเพื่อเชื่อมต่อกับส่วนประกอบ UI ใด ๆ

การติดตั้ง

ผู้จัดการแพ็คเกจ 

 # npm
npm install @mlc-ai/web-llm
# yarn
yarn add @mlc-ai/web-llm
# or pnpm
pnpm install @mlc-ai/web-llm

จากนั้นนำเข้าโมดูลในรหัสของคุณ 

 // Import everything
import * as webllm from "@mlc-ai/web-llm" ;
// Or only import what you need
import { CreateMLCEngine } from "@mlc-ai/web-llm" ;

การจัดส่ง CDN

ขอบคุณ JSDELIVR.com WEBLLM สามารถนำเข้าโดยตรงผ่าน URL และทำงานนอกกรอบบนแพลตฟอร์มการพัฒนาคลาวด์เช่น JSFIDDLE.NET, CodePen.io และ Scribbler: 

 import * as webllm from "https://esm.run/@mlc-ai/web-llm" ;

นอกจากนี้ยังสามารถนำเข้าแบบไดนามิกเป็น: 

 const webllm = await import ( "https://esm.run/@mlc-ai/web-llm" ) ;

สร้าง mlcengine

การดำเนินการส่วนใหญ่ใน WebLLM จะถูกเรียกใช้ผ่านอินเตอร์เฟส MLCEngine คุณสามารถสร้างอินสแตนซ์ MLCEngine และโหลดโมเดลได้โดยเรียกฟังก์ชันโรงงาน CreateMLCEngine()

(โปรดทราบว่าโมเดลการโหลดต้องมีการดาวน์โหลดและอาจใช้เวลาเป็นจำนวนมากสำหรับการวิ่งครั้งแรกโดยไม่ต้องแคชก่อนหน้านี้คุณควรจัดการการโทรแบบอะซิงโครนัสนี้อย่างถูกต้อง) 

 import { CreateMLCEngine } from "@mlc-ai/web-llm" ;

// Callback function to update model loading progress
const initProgressCallback = ( initProgress ) => {
  console . log ( initProgress ) ;
}
const selectedModel = "Llama-3.1-8B-Instruct-q4f32_1-MLC" ;

const engine = await CreateMLCEngine (
  selectedModel ,
  { initProgressCallback : initProgressCallback } , // engineConfig
) ;

ภายใต้ประทุนฟังก์ชั่นโรงงานนี้ทำขั้นตอนต่อไปนี้สำหรับการสร้างอินสแตนซ์ของเครื่องยนต์ (ซิงโครนัส) ก่อนจากนั้นโหลดโมเดล (อะซิงโครนัส) คุณสามารถทำแยกต่างหากในแอปพลิเคชันของคุณ 

 import { MLCEngine } from "@mlc-ai/web-llm" ;

// This is a synchronous call that returns immediately
const engine = new MLCEngine ( {
  initProgressCallback : initProgressCallback
} ) ;

// This is an asynchronous call and can take a long time to finish
await engine . reload ( selectedModel ) ;

การแชทเสร็จสิ้น

หลังจากเริ่มต้นการเริ่มต้นเครื่องยนต์แล้วตอนนี้คุณสามารถเรียกใช้การแชทเสร็จสมบูรณ์โดยใช้ OpenAi Style Chat APIs ผ่านทาง engine.chat.completions Interface สำหรับรายการทั้งหมดของพารามิเตอร์และคำอธิบายของพวกเขาตรวจสอบส่วนด้านล่างและการอ้างอิง OpenAI API

(หมายเหตุ: พารามิเตอร์ model ไม่ได้รับการสนับสนุนและจะถูกละเว้นที่นี่แทนโทร CreateMLCEngine(model) หรือ engine.reload(model) แทนดังแสดงใน create MLCEngine ด้านบน) 

 const messages = [
  { role : "system" , content : "You are a helpful AI assistant." } ,
  { role : "user" , content : "Hello!" } ,
]

const reply = await engine . chat . completions . create ( {
  messages ,
} ) ;
console . log ( reply . choices [ 0 ] . message ) ;
console . log ( reply . usage ) ;

การสตรีม

WebLlm ยังรองรับการสร้างการแชทสตรีมมิ่ง หากต้องการใช้งานเพียงแค่ผ่าน stream: true กับ engine.chat.completions.create Call 

 const messages = [
  { role : "system" , content : "You are a helpful AI assistant." } ,
  { role : "user" , content : "Hello!" } ,
]

// Chunks is an AsyncGenerator object
const chunks = await engine . chat . completions . create ( {
  messages ,
  temperature : 1 ,
  stream : true , // <-- Enable streaming
  stream_options : { include_usage : true } ,
} ) ;

let reply = "" ;
for await ( const chunk of chunks ) {
  reply += chunk . choices [ 0 ] ?. delta . content || "" ;
  console . log ( reply ) ;
  if ( chunk . usage ) {
    console . log ( chunk . usage ) ; // only last chunk has usage
  }
}

const fullReply = await engine . getMessage ( ) ;
console . log ( fullReply ) ;

การใช้งานขั้นสูง

ใช้คนงาน

คุณสามารถทำการคำนวณอย่างหนักในสคริปต์คนงานเพื่อเพิ่มประสิทธิภาพแอปพลิเคชันของคุณ ในการทำเช่นนั้นคุณต้อง:

  1. สร้างตัวจัดการในเธรดคนงานที่สื่อสารกับส่วนหน้าในขณะที่จัดการคำขอ
  2. สร้างเอ็นจิ้นคนงานในแอปพลิเคชันหลักของคุณซึ่งภายใต้ฮูดจะส่งข้อความไปยังตัวจัดการในเธรดคนงาน

สำหรับการใช้งานโดยละเอียดของคนงานประเภทต่าง ๆ ให้ตรวจสอบส่วนต่อไปนี้

ผู้ปฏิบัติงานบนเว็บเฉพาะ

WebLlm มาพร้อมกับการสนับสนุน API สำหรับผู้ไปพบเว็บเพื่อให้คุณสามารถเชื่อมต่อกระบวนการสร้างเป็นเธรดคนงานแยกต่างหากเพื่อให้การคำนวณในเธรดคนงานจะไม่รบกวน UI

เราสร้างตัวจัดการในเธรดคนงานที่สื่อสารกับส่วนหน้าในขณะที่จัดการคำขอ 

 // worker.ts
import { WebWorkerMLCEngineHandler } from "@mlc-ai/web-llm" ;

// A handler that resides in the worker thread
const handler = new WebWorkerMLCEngineHandler ( ) ;
self . onmessage = ( msg : MessageEvent ) => {
  handler . onmessage ( msg ) ;
} ;

ในตรรกะหลักเราสร้าง WebWorkerMLCEngine ที่ใช้ MLCEngineInterface เดียวกัน ส่วนที่เหลือของตรรกะยังคงเหมือนเดิม 

 // main.ts
import { CreateWebWorkerMLCEngine } from "@mlc-ai/web-llm" ;

async function main ( ) {
  // Use a WebWorkerMLCEngine instead of MLCEngine here
  const engine = await CreateWebWorkerMLCEngine (
    new Worker (
      new URL ( "./worker.ts" , import . meta . url ) , 
      {
        type : "module" ,
      }
    ) ,
    selectedModel ,
    { initProgressCallback } , // engineConfig
  ) ;

  // everything else remains the same
}

ใช้ผู้ปฏิบัติงานบริการ

WebLLM มาพร้อมกับการสนับสนุน API สำหรับผู้ให้บริการเพื่อให้คุณสามารถเชื่อมต่อกระบวนการสร้างเป็นพนักงานบริการเพื่อหลีกเลี่ยงการโหลดโมเดลในทุกหน้าการเยี่ยมชมและเพิ่มประสิทธิภาพประสบการณ์ออฟไลน์ของแอปพลิเคชันของคุณ

(หมายเหตุวงจรชีวิตของผู้ปฏิบัติงานบริการได้รับการจัดการโดยเบราว์เซอร์และสามารถฆ่าได้ตลอดเวลาโดย keepAliveMs ต้องแจ้ง Webapp. ServiceWorkerMLCEngine จะพยายามรักษาด้ายผู้ปฏิบัติงานให้บริการโดยการส่งเหตุการณ์การเต้นของหัวใจเป็นระยะ แต่แอป ServiceWorkerMLCEngine เค missedHeatbeat ของคุณควรรวมถึงการจัดการข้อผิดพลาดที่เหมาะสม

เราสร้างตัวจัดการในเธรดคนงานที่สื่อสารกับส่วนหน้าในขณะที่จัดการคำขอ 

 // sw.ts
import { ServiceWorkerMLCEngineHandler } from "@mlc-ai/web-llm" ;

let handler : ServiceWorkerMLCEngineHandler ;

self . addEventListener ( "activate" , function ( event ) {
  handler = new ServiceWorkerMLCEngineHandler ( ) ;
  console . log ( "Service Worker is ready" ) ;
} ) ;

จากนั้นในตรรกะหลักเราลงทะเบียนผู้ปฏิบัติงานบริการและสร้างเครื่องยนต์โดยใช้ฟังก์ชั่น CreateServiceWorkerMLCEngine ส่วนที่เหลือของตรรกะยังคงเหมือนเดิม 

 // main.ts
import { MLCEngineInterface , CreateServiceWorkerMLCEngine } from "@mlc-ai/web-llm" ;

if ( "serviceWorker" in navigator ) {
  navigator . serviceWorker . register (
    new URL ( "sw.ts" , import . meta . url ) ,  // worker script
    { type : "module" } ,
  ) ;
}

const engine : MLCEngineInterface =
  await CreateServiceWorkerMLCEngine (
    selectedModel ,
    { initProgressCallback } , // engineConfig
  ) ;

คุณสามารถค้นหาตัวอย่างที่สมบูรณ์เกี่ยวกับวิธีการเรียกใช้ WebLlm ในพนักงานบริการในตัวอย่าง/คนงานที่ให้บริการ

ส่วนขยายโครเมี่ยม

นอกจากนี้คุณยังสามารถค้นหาตัวอย่างของการขยายการสร้างโครเมี่ยมด้วย webllm ในตัวอย่าง/การขยายโครเมี่ยมและตัวอย่าง/Chrome-extension-webgpu-service-worker หลังหนึ่งใช้ประโยชน์จากพนักงานบริการดังนั้นส่วนขยายจะคงอยู่ในพื้นหลัง นอกจากนี้คุณสามารถสำรวจโครงการเต็มรูปแบบของส่วนขยาย Chrome อีกครั้งผู้ช่วย Webllm ซึ่งใช้ประโยชน์จาก webllm ที่นี่

ความเข้ากันได้ของ openai เต็มรูปแบบ

WebLlm ได้รับการออกแบบให้เข้ากันได้อย่างเต็มที่กับ OpenAI API ดังนั้นนอกเหนือจากการสร้าง chatbot อย่างง่ายคุณยังสามารถมีฟังก์ชันต่อไปนี้ด้วย webllm:

  • สตรีมมิ่ง: ส่งกลับเป็นชิ้นส่วนแบบเรียลไทม์ในรูปแบบของ asyncgenerator
  • JSON-Mode: มั่นใจได้ว่าเอาต์พุตอยู่ในรูปแบบ JSON ได้อย่างมีประสิทธิภาพดูการอ้างอิง OpenAI สำหรับข้อมูลเพิ่มเติม
  • Seed-to-Reproduce: ใช้การเพาะเพื่อให้แน่ใจว่าเอาท์พุทที่ทำซ้ำได้ด้วย seed พันธุ์
  • ฟังก์ชั่นการเรียก (WIP): การเรียกใช้ฟังก์ชั่นด้วย tools ฟิลด์และ tool_choice (พร้อมการสนับสนุนเบื้องต้น); หรือฟังก์ชั่นการโทรด้วยตนเองโดยไม่มี tools หรือ tool_choice (รักษาความยืดหยุ่นที่สุด)

โมเดลที่กำหนดเอง

WebLLM ทำงานเป็นโครงการสหายของ MLC LLM และรองรับโมเดลที่กำหนดเองในรูปแบบ MLC มันนำสิ่งประดิษฐ์แบบจำลองกลับมาใช้ใหม่และสร้างการไหลของ MLC LLM ในการรวบรวมและใช้โมเดลของคุณเองด้วย webllm โปรดตรวจสอบเอกสาร MLC LLM เกี่ยวกับวิธีการรวบรวมและปรับใช้น้ำหนักและไลบรารีรุ่นใหม่ไปยัง WebLlm

ที่นี่เราไปผ่านแนวคิดระดับสูง มีสององค์ประกอบของแพ็คเกจ WebLLM ที่เปิดใช้งานรุ่นใหม่และตัวแปรน้ำหนัก

  • model : มี URL ในการสร้างแบบจำลองสิ่งประดิษฐ์เช่นน้ำหนักและเมตาดาต้า
  • model_lib : URL ไปยังไลบรารีแอสเซมบลีเว็บ (เช่นไฟล์ WASM) ที่มี executables เพื่อเร่งการคำนวณแบบจำลอง

ทั้งสองสามารถปรับแต่งได้ใน webllm 

 import { CreateMLCEngine } from "@mlc-ai/web-llm" ;

async main ( ) {
  const appConfig = {
    "model_list" : [
      {
        "model" : "/url/to/my/llama" ,
        "model_id" : "MyLlama-3b-v1-q4f32_0" ,
        "model_lib" : "/url/to/myllama3b.wasm" ,
      }
    ] ,
  } ;
  // override default
  const chatOpts = {
    "repetition_penalty" : 1.01
  } ;

  // load a prebuilt model
  // with a chat option override and app config
  // under the hood, it will load the model from myLlamaUrl
  // and cache it in the browser cache
  // The chat will also load the model library from "/url/to/myllama3b.wasm",
  // assuming that it is compatible to the model in myLlamaUrl.
  const engine = await CreateMLCEngine (
    "MyLlama-3b-v1-q4f32_0" ,
    { appConfig } , // engineConfig
    chatOpts ,
  ) ;
}

ในหลายกรณีเราต้องการจัดหาตัวแปรน้ำหนักแบบจำลองเท่านั้น แต่ไม่จำเป็นต้องเป็นรุ่นใหม่ (เช่น NeuralHermes-Mistral สามารถนำไลบรารีโมเดลของ Mistral กลับมาใช้ใหม่ได้) สำหรับตัวอย่างว่าห้องสมุดโมเดลสามารถใช้ร่วมกันได้อย่างไรโดยรุ่นที่แตกต่างกันให้ดูที่ webllm.prebuiltAppConfig

สร้างแพ็คเกจ webllm จากแหล่งที่มา

หมายเหตุ: คุณไม่จำเป็นต้องสร้างจากแหล่งที่มาเว้นแต่คุณต้องการแก้ไขแพ็คเกจ WebLLM หากต้องการใช้ NPM เพียงติดตามการเริ่มต้นหรือตัวอย่างใด ๆ แทน

เพื่อสร้างจากแหล่งที่มาเพียงแค่เรียกใช้: 

npm install
npm run build

จากนั้นเพื่อทดสอบผลกระทบของการเปลี่ยนแปลงรหัสของคุณในตัวอย่างภายใน examples/get-started/package.json เปลี่ยนจาก "@mlc-ai/web-llm": "^0.2.77" เป็น "@mlc-ai/web-llm": ../..

จากนั้นเรียกใช้: 

 cd examples/get-started
npm install
npm start

โปรดทราบว่าบางครั้งคุณจะต้องสลับระหว่าง file:../.. และ ../.. เพื่อทริกเกอร์ NPM เพื่อรับรู้การเปลี่ยนแปลงใหม่ ในกรณีที่เลวร้ายที่สุดคุณสามารถเรียกใช้: 

 cd examples/get-started
rm -rf node_modules dist package-lock.json .parcel-cache
npm install
npm start

ในกรณีที่คุณต้องการสร้าง TVMJs จากแหล่งที่มา

รันไทม์ของ WebLlm ส่วนใหญ่ขึ้นอยู่กับ TVMJS: https://github.com/apache/tvm/tree/main/web

ในขณะที่ยังมีอยู่ในแพ็คเกจ NPM: https://www.npmjs.com/package/@mlc-ai/web-runtime คุณสามารถสร้างจากแหล่งที่มาได้หากต้องการทำตามขั้นตอนด้านล่าง

  1. ติดตั้ง emscripten มันเป็นคอมไพเลอร์ที่ใช้ LLVM ที่รวบรวมซอร์สโค้ด C/C ++ ไปยัง WebAssembly

    • ทำตามคำแนะนำการติดตั้งเพื่อติดตั้ง EMSDK ล่าสุด
    • แหล่งที่มา emsdk_env.sh โดย source path/to/emsdk_env.sh เพื่อให้ emcc สามารถเข้าถึงได้จากเส้นทางและคำสั่ง emcc ทำงาน

    เราสามารถตรวจสอบการติดตั้งที่ประสบความสำเร็จโดยลองใช้ emcc Terminal

    หมายเหตุ: เมื่อเร็ว ๆ นี้เราพบว่าการใช้เวอร์ชัน emcc ล่าสุดอาจพบปัญหาในระหว่างการรันไทม์ ใช้ ./emsdk install 3.1.56 แทน ./emsdk install latest สำหรับตอนนี้เป็นวิธีแก้ปัญหา ข้อผิดพลาดอาจดูเหมือน 

     Init error, LinkError: WebAssembly.instantiate(): Import #6 module="wasi_snapshot_preview1"
function="proc_exit": function import requires a callable

  2. ใน ./package.json , เปลี่ยนจาก "@mlc-ai/web-runtime": "0.18.0-dev2", เป็น "@mlc-ai/web-runtime": "file:./tvm_home/web",

  3. การตั้งค่าสภาพแวดล้อมที่จำเป็น

    เตรียมการพึ่งพาที่จำเป็นทั้งหมดสำหรับการสร้างเว็บ: 

    ./scripts/prep_deps.sh

    ในขั้นตอนนี้หากไม่ได้กำหนด $TVM_SOURCE_DIR ในสภาพแวดล้อมเราจะดำเนินการบรรทัดต่อไปนี้เพื่อสร้างการพึ่งพา tvmjs : 

    git clone https://github.com/mlc-ai/relax 3rdparty/tvm-unity --recursive

    นี่เป็นส่วนหัวปัจจุบันของ mlc-ai/relax อย่างไรก็ตามอาจไม่ได้เป็นสาขาที่ถูกต้องหรือผูกพันกับโคลน ในการสร้างเวอร์ชัน NPM ที่เฉพาะเจาะจงจากแหล่งที่มาให้ดูรุ่น Bump PR ซึ่งระบุว่าสาขาใด (เช่น mlc-ai/relax หรือ apache/tvm ) ตัวอย่างเช่นเวอร์ชัน 0.2.52 ตามเวอร์ชัน Bump PR #521 ถูกสร้างขึ้นโดย mlc-ai/relax ตรวจสอบการกระทำต่อไปนี้ apache/tvm

    นอกจากนี้ --recursive จำเป็นต้องมีการตอบโต้และสำคัญ มิฉะนั้นคุณอาจพบข้อผิดพลาดเช่น fatal error: 'dlpack/dlpack.h' file not found

  4. สร้างแพ็คเกจ webllm 

    npm run build

  5. ตรวจสอบบางส่วนของแพคเกจย่อย

    จากนั้นคุณสามารถไปที่โฟลเดอร์ย่อยในตัวอย่างเพื่อตรวจสอบบางส่วนของแพคเกจย่อย เราใช้ parcelv2 สำหรับการรวมกลุ่ม แม้ว่าพัสดุจะไม่ค่อยดีนักในการติดตามไดเรกทอรีหลักของการเปลี่ยนแปลงบางครั้ง เมื่อคุณทำการเปลี่ยนแปลงในแพ็คเกจ WebLLM ลองแก้ไข package.json ของโฟลเดอร์ย่อยและบันทึกซึ่งจะทำให้พัสดุสร้างใหม่

ลิงค์

  • แอพสาธิต: แชท WebLlm
  • หากคุณต้องการเรียกใช้ LLM บนรันไทม์ดั้งเดิมให้ตรวจสอบ MLC-LLM
  • คุณอาจสนใจการแพร่กระจายของเว็บที่มั่นคง

การรับทราบ

โครงการนี้เริ่มต้นโดยสมาชิกจาก CMU Catalyst, UW Sampl, SJTU, Octoml และชุมชน MLC เรายินดีที่จะพัฒนาและสนับสนุนชุมชน ML โอเพนซอร์สต่อไป

โครงการนี้เป็นไปได้เพียงเพราะระบบนิเวศโอเพนซอร์สไหล่ที่เรายืนอยู่ เราต้องการขอบคุณชุมชน Apache TVM และนักพัฒนาของ TVM Unity Tofe สมาชิกชุมชนโอเพนซอร์ซ ML ทำให้แบบจำลองเหล่านี้เปิดเผยต่อสาธารณะ Pytorch และการกอดชุมชนใบหน้าทำให้แบบจำลองเหล่านี้สามารถเข้าถึงได้ เราขอขอบคุณทีมที่อยู่เบื้องหลัง Vicuna, Sentencepiece, Llama และ Alpaca นอกจากนี้เรายังขอขอบคุณชุมชน WebAssembly, Emscripten และ WebGPU สุดท้ายต้องขอบคุณ Dawn และนักพัฒนา WebGPU

การอ้างอิง

หากคุณพบว่าโครงการนี้มีประโยชน์โปรดอ้างอิง: 

 @misc{ruan2024webllmhighperformanceinbrowserllm,
      title={WebLLM: A High-Performance In-Browser LLM Inference Engine}, 
      author={Charlie F. Ruan and Yucheng Qin and Xun Zhou and Ruihang Lai and Hongyi Jin and Yixin Dong and Bohan Hou and Meng-Shiun Yu and Yiyan Zhai and Sudeep Agarwal and Hangrui Cao and Siyuan Feng and Tianqi Chen},
      year={2024},
      eprint={2412.15803},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      url={https://arxiv.org/abs/2412.15803}, 
}

ผู้มีส่วนร่วม

⬆กลับไปด้านบน⬆

ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด