การเพิ่มประสิทธิภาพ WebAssembly และ WebGPU สำหรับ Web AI ที่เร็วขึ้น ตอนที่ 2

เอกสารนี้มีเนื้อหาต่อเนื่องมาจากการเพิ่มประสิทธิภาพ WebAssembly และ WebGPU เพื่อ Web AI ที่เร็วขึ้น ตอนที่ 1 เราขอแนะนำให้คุณอ่านโพสต์นี้หรือดูการพูดคุยที่ IO 24 ก่อนดำเนินการต่อ

WebGPU

โดย WebGPU ช่วยให้เว็บแอปพลิเคชันสามารถเข้าถึงฮาร์ดแวร์ GPU ของไคลเอ็นต์เพื่อการคำนวณที่ทำงานพร้อมกันอย่างมีประสิทธิภาพ ตั้งแต่เปิดตัว WebGPU ใน Chrome เราได้เห็นการสาธิตปัญญาประดิษฐ์ (AI) และแมชชีนเลิร์นนิง (ML) ที่น่าทึ่งบนเว็บ

ตัวอย่างเช่น การกระจาย Web Stable Diffusion แสดงให้เห็นว่าสามารถใช้ AI เพื่อสร้างรูปภาพจากข้อความในเบราว์เซอร์โดยตรงได้ เมื่อต้นปีนี้ ทีม Mediapipe ของ Google ได้เผยแพร่การสนับสนุนเวอร์ชันทดลองสำหรับการอนุมานโมเดลภาษาขนาดใหญ่

ภาพเคลื่อนไหวต่อไปนี้แสดง Gemma ซึ่งเป็นโมเดลภาษาขนาดใหญ่ (LLM) แบบโอเพนซอร์สของ Google ที่ทำงานในอุปกรณ์ใน Chrome แบบเรียลไทม์

การสาธิต Hugging Face ต่อไปนี้สำหรับ Segment Anything Model ของ Meta ต่อไปนี้จะสร้างมาสก์ออบเจ็กต์คุณภาพสูงบนไคลเอ็นต์

นี่เป็นเพียง 2 โปรเจ็กต์ที่ยอดเยี่ยมซึ่งแสดงให้เห็นศักยภาพของ WebGPU สำหรับ AI และ ML ซึ่ง WebGPU ช่วยให้โมเดลเหล่านี้และโมเดลอื่นๆ ทำงานเร็วกว่าบน CPU ได้อย่างมาก

การเปรียบเทียบ WebGPU สำหรับการฝังข้อความของ Hugging Face แสดงให้เห็นถึงการเพิ่มขึ้นอย่างรวดเร็วเมื่อเทียบกับการใช้ CPU ในรุ่นเดียวกัน WebGPU ทำงานได้เร็วขึ้นกว่า 30 เท่าบนแล็ปท็อป Apple M1 Max ผู้ให้บริการรายอื่นๆ รายงานว่า WebGPU ช่วยเร่งการเปรียบเทียบมากกว่า 120 เท่า

การปรับปรุงฟีเจอร์ WebGPU สำหรับ AI และ ML

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

ในบรรดาการปรับปรุงมากมายที่เกิดขึ้นกับ WebGPU ในปีที่ผ่านมา เรายังได้เพิ่มความสามารถใหม่ๆ อย่างต่อเนื่องเพื่อปรับปรุงประสิทธิภาพ ML และ AI บนเว็บ เมื่อเร็วๆ นี้เราได้เปิดตัว 2 ฟีเจอร์ใหม่ ได้แก่ ทศนิยม 16 บิตและผลิตภัณฑ์แบบจุดจำนวนเต็ม

จุดลอยตัว 16 บิต

อย่าลืมว่าภาระงาน ML ไม่จำเป็นต้องใช้ความแม่นยำ shader-f16 เป็นฟีเจอร์ที่อนุญาตให้ใช้ประเภท f16 ในภาษาการแรเงา WebGPU ประเภทจุดลอยตัวนี้ใช้ 16 บิต ไม่ใช่ 32 บิตตามปกติ f16 มีช่วงที่น้อยกว่าและมีความแม่นยำน้อยกว่า แต่สำหรับโมเดล ML จำนวนมากนั้นก็เพียงพอแล้ว

ฟีเจอร์นี้ช่วยเพิ่มประสิทธิภาพได้ 3 วิธีดังนี้

• หน่วยความจำลดลง: Tensor ที่มีองค์ประกอบ f16 จะใช้พื้นที่ครึ่งหนึ่ง ซึ่งจะลดการใช้หน่วยความจำลงครึ่งหนึ่ง การคำนวณของ GPU มักคอขวดบนแบนด์วิดท์หน่วยความจำ ดังนั้นหน่วยความจำครึ่งหนึ่งจึงมักหมายความว่าเครื่องมือปรับแสงเงาจะทำงานได้เร็วขึ้น 2 เท่า ในทางเทคนิค คุณไม่จำเป็นต้องใช้ f16 เพื่อประหยัดแบนด์วิดท์หน่วยความจำ คุณสามารถจัดเก็บข้อมูลในรูปแบบที่มีความแม่นยำต่ำ แล้วขยายออกให้เต็ม f32 ในหน้าต่างเฉดสีเพื่อการคำนวณ แต่ GPU จะใช้พลังในการประมวลผลเพิ่มเติมเพื่อแพ็กและคลายการแพคข้อมูล

• การแปลงข้อมูลลดลง: f16 ใช้การประมวลผลน้อยลงโดยการลดการแปลงข้อมูล ระบบสามารถจัดเก็บข้อมูลความแม่นยำต่ำแล้วนำไปใช้โดยตรงโดยไม่ต้องแปลง

• การทำงานพร้อมกันที่เพิ่มขึ้น: GPU สมัยใหม่สามารถใส่ค่าได้มากขึ้นพร้อมกันในหน่วยการดำเนินการของ GPU ซึ่งช่วยให้คำนวณแบบขนานได้มากขึ้น ตัวอย่างเช่น GPU ที่รองรับการดำเนินการจุดลอยตัว f32 สูงสุด 5 ล้านล้านจุดต่อวินาทีอาจรองรับการดำเนินการจุดลอยตัว f16 ได้ 10 ล้านล้านจุดต่อวินาที

WebLLM เป็นโปรเจ็กต์ที่เรียกใช้โมเดลภาษาขนาดใหญ่ได้หลายรายการ โดยใช้ Apache TVM ซึ่งเป็นเฟรมเวิร์กคอมไพเลอร์แมชชีนเลิร์นนิงแบบโอเพนซอร์ส

ผมขอให้ WebLLM วางแผนการเดินทางไปปารีส โดยใช้โมเดลพารามิเตอร์ Llama 3 จำนวน 8 พันล้านรายการ ผลลัพธ์แสดงให้เห็นว่าในระยะการกรอกข้อมูลล่วงหน้าของโมเดล f16 เร็วกว่า f32 2.1 เท่า ในระหว่างขั้นตอนการถอดรหัส ความเร็วจะเร็วขึ้นกว่า 1.3 เท่า

แอปพลิเคชันต้องยืนยันก่อนว่าอะแดปเตอร์ GPU รองรับ f16 และหากพร้อมใช้งาน ให้เปิดใช้งานอย่างชัดแจ้งเมื่อขออุปกรณ์ GPU หากระบบไม่รองรับ f16 คุณจะขอในอาร์เรย์ requiredFeatures ไม่ได้

// main.js

const adapter = await navigator.gpu.requestAdapter();
const supportsF16 = adapter.features.has('shader-f16');
if (supportsF16) {
  // Use f16.
  const device = await adapter.requestDevice({
    requiredFeatures: ['shader-f16'],
  });
  initApp(device);
}

จากนั้นให้เปิดใช้งาน f16 ที่ด้านบนสุดอย่างชัดแจ้งในตัวสร้างเงา WebGPU หลังจากนั้น คุณจะสามารถใช้ข้อมูลดังกล่าวภายในตัวควบคุมเฉดสีได้เช่นเดียวกับข้อมูลแบบลอยประเภทอื่นๆ

// my-shader.wgsl

enable f16;

struct Data {
  values : array<vec4<f16>>
}
@group(0) @binding(0) var<storage, read> data : Data;
@compute @workgroup_size(64) fn main(@builtin(global_invocation_id) gid : vec3u) {
  let value : vec4<f16> = data.values[gid.x];
  ...
}

แพ็กผลิตภัณฑ์จำนวนเต็มแบบจุด

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

มี GPU เพียงไม่กี่ตัวที่รองรับค่า 8 บิตโดยค่าเริ่มต้น หน้านี้คือปลายทางที่บรรจุผลิตภัณฑ์แบบจุดจำนวนเต็ม เราจัดส่ง DP4a ใน Chrome 123

GPU สมัยใหม่มีคำสั่งพิเศษในการเขียนจำนวนเต็ม 32 บิต 2 ตัว ตีความแต่ละตัวเป็นจำนวนเต็ม 8 บิตที่บรรจุมาเรียงต่อกัน 4 ตัว และคำนวณผลคูณระหว่างจุดระหว่างคอมโพเนนต์

ซึ่งจะเป็นประโยชน์อย่างยิ่งสำหรับ AI และแมชชีนเลิร์นนิงเพราะเคอร์เนลการคูณเมตริกซ์ประกอบด้วยผลิตภัณฑ์แบบจุดจำนวนมาก

เช่น สมมติว่าเมทริกซ์ 4 x 8 คูณกับเวกเตอร์ 8 x 1 การคำนวณจะอาศัยการคูณ 4 จุดเพื่อคำนวณแต่ละค่าในเวกเตอร์เอาต์พุต ก ข ค และง

กระบวนการในการคํานวณเอาต์พุตเหล่านี้แต่ละรายการจะเหมือนกัน เราจะมาดูขั้นตอนที่เกี่ยวข้องในการคำนวณขั้นตอนใดขั้นตอนหนึ่ง ก่อนการคำนวณ เราจะต้องแปลงข้อมูลจำนวนเต็ม 8 บิตเป็นประเภทที่เราสามารถคำนวณเลขได้ เช่น f16 จากนั้นจึงเรียกใช้การคูณองค์ประกอบ และสุดท้ายก็เพิ่มผลิตภัณฑ์ทั้งหมดเข้าด้วยกัน โดยรวมแล้ว สำหรับการคูณเวกเตอร์เมทริกซ์ทั้งหมด เราจะคำนวณจำนวนเต็ม 40 รายการเพื่อทำให้ Conversion ลอยตัวเพื่อคลายการแพคข้อมูล การคูณจำนวนลอยตัว 32 รายการ และการบวกจำนวนลอยตัว 28 รายการ

สำหรับเมทริกซ์ขนาดใหญ่ที่มีการดำเนินการมากกว่า การบรรจุผลิตภัณฑ์จำนวนเต็มแบบจุดช่วยลดปริมาณงานได้

สำหรับเอาต์พุตแต่ละรายการในเวกเตอร์ของผลลัพธ์ เราดำเนินการผลิตภัณฑ์แบบจุด 2 จุดโดยใช้ dot4U8Packed การแรเงา WebGPU ในตัว จากนั้นจึงนำผลลัพธ์มาบวกกัน โดยรวมแล้ว สำหรับการคูณเวกเตอร์ของเมทริกซ์ทั้งหมด เราจะไม่ทำการแปลงข้อมูลใดๆ เราดำเนินการผลิตภัณฑ์แบบจุด 8 จุด และบวกจำนวนเต็ม 4 ตัว

เราได้ทดสอบผลิตภัณฑ์จำนวนเต็มที่บรรจุหีบห่อด้วยข้อมูล 8 บิตบน GPU สำหรับผู้บริโภคที่หลากหลาย เมื่อเปรียบเทียบกับจุดลอยตัว 16 บิต เราจะเห็นว่า 8 บิตนั้นเร็วกว่า 1.6 ถึง 2.8 เท่า เมื่อเราใช้ผลิตภัณฑ์แบบจุดจำนวนเต็มที่อัดแน่นด้วยอย่างต่อเนื่อง ประสิทธิภาพก็จะดียิ่งขึ้นไปอีก ซึ่งเร็วขึ้น 1.7-2.9 เท่า

วันที่

ตรวจหาการรองรับเบราว์เซอร์ในพร็อพเพอร์ตี้ wgslLanguageFeatures หาก GPU ไม่รองรับผลิตภัณฑ์ที่แพ็กไว้ตั้งแต่แรก เบราว์เซอร์ Polyfill ก็คือการใช้งานของตัวเอง

// main.js

if (navigator.gpu.wgslLanguageFeatures.has('packed_4x8_integer_dot_product')) {
  // Use dot4U8Packed, dot4I8Packed builtin
  // functions in the shaders.
}

ความแตกต่างของข้อมูลโค้ดต่อไปนี้ (ความแตกต่าง) ซึ่งไฮไลต์การเปลี่ยนแปลงที่จำเป็นในการใช้ผลิตภัณฑ์ที่ใส่จำนวนเต็มที่บรรจุมาในตัวสร้างเงา WebGPU

ก่อน — ตัวปรับแสงเงา WebGPU ที่รวบรวมผลิตภัณฑ์แบบจุดบางส่วนไว้ในตัวแปร "sum" ที่จุดสิ้นสุดของลูป "sum" จะเก็บผลคูณแบบเต็มจุดระหว่างเวกเตอร์และ 1 แถวของเมทริกซ์อินพุต

// my-dot-product.wgsl

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) gid : vec3u) {
  var sum : f16;
  let start = gid.x * uniforms.dim;
  for (var i = 0u; i < uniforms.dim; i++) {
    let v1 : vec4<f16> = vector.values[i];
    let v2 : vec4<f16> = matrix.values[start + i];
    sum += dot(v1, v2);
  }
}

หลัง - ตัวปรับแสงเงา WebGPU ที่เขียนขึ้นเพื่อใช้ผลิตภัณฑ์แบบจุดจำนวนเต็มที่แพ็กไว้ ความแตกต่างที่สำคัญคือ แทนที่จะโหลดค่าจำนวนลอยตัว 4 ค่าจากเวกเตอร์และเมทริกซ์ ตัวปรับแสงสีนี้จะโหลดจำนวนเต็ม 32 บิตเดี่ยว จำนวนเต็ม 32 บิตนี้มีข้อมูลของค่าจำนวนเต็ม 8 บิต 4 ค่า จากนั้น เราจะเรียก dot4U8Packed เพื่อคำนวณผลคูณของจุดของทั้ง 2 ค่า

// my-dot-product.wgsl

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) gid : vec3u) {
  var sum : f32;
  let start = gid.x * uniforms.dim;
  for (var i = 0u; i < uniforms.dim; i++) {
    let v1 : u32 = vector.values[i];
    let v2 : u32 = matrix.values[start + i];
    sum += dot4U8Packed(v1, v2);
  }
}

ผลิตภัณฑ์จำนวนจุดลอยตัว 16 บิตและผลิตภัณฑ์จำนวนเต็มที่อัดแน่นไปด้วยเป็นฟีเจอร์ที่จัดส่งใน Chrome ที่ช่วยเร่งระบบ AI และ ML จุดลอยตัว 16 บิตจะใช้ได้เมื่อฮาร์ดแวร์รองรับ และ Chrome จะใช้ผลิตภัณฑ์จุดจำนวนเต็มที่บรรจุหีบห่อในอุปกรณ์ทั้งหมด

ตอนนี้คุณใช้ฟีเจอร์เหล่านี้ใน Chrome เวอร์ชันเสถียรได้แล้วเพื่อประสิทธิภาพที่ดีขึ้น

ฟีเจอร์ที่เสนอ

ในอนาคต เรากำลังตรวจสอบคุณลักษณะอีก 2 อย่าง ได้แก่ กลุ่มย่อย และการคูณเมทริกซ์แบบร่วมมือ

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

เราได้กลั่นกรองสิ่งที่ได้กำหนดไว้ให้เป็นข้อเสนอที่เราได้กล่าวถึงกลุ่มมาตรฐาน WebGPU นอกจากนี้ เราได้สร้างต้นแบบกลุ่มย่อยใน Chrome โดยใช้ Flag ทดลอง และได้นำผลลัพธ์เบื้องต้นไปอภิปรายด้วย ปัญหาหลักคือวิธีดูแลให้เกิดลักษณะการทำงานที่สามารถถ่ายโอนได้

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

เราสำรวจการรองรับใน GPU API ที่เกี่ยวข้องและวางแผนที่จะเสนอข้อเสนอไปยังกลุ่มการกำหนดมาตรฐาน WebGPU เช่นเดียวกับกลุ่มย่อย เราคาดว่าการสนทนาส่วนใหญ่จะอยู่ที่จุดที่สามารถถ่ายโอนได้

ในการประเมินประสิทธิภาพของการดำเนินงานของกลุ่มย่อย ในแอปพลิเคชันจริง เราได้ผสานรวมการสนับสนุนเชิงทดลองสำหรับกลุ่มย่อยไว้ใน MediaPipe และทดสอบกับต้นแบบของ Chrome สำหรับการดำเนินการของกลุ่มย่อย

เราใช้กลุ่มย่อยในเคอร์เนล GPU ของระยะการกรอกข้อมูลล่วงหน้าของโมเดลภาษาขนาดใหญ่ ฉันจึงรายงานเฉพาะการเร่งสำหรับระยะการป้อนข้อมูลล่วงหน้าเท่านั้น ส่วนใน Intel GPU เราจะเห็นว่ากลุ่มย่อยทำงานเร็วกว่าเกณฑ์พื้นฐาน 2.5 เท่า อย่างไรก็ตาม การปรับปรุงเหล่านี้จะไม่สอดคล้องกันใน GPU ต่างๆ

วันที่

แผนภูมิถัดไปแสดงผลลัพธ์ของการใช้กลุ่มย่อยเพื่อเพิ่มประสิทธิภาพเมทริกซ์การคูณไมโครใน GPU ของผู้ใช้หลายรายการ การคูณเมทริกซ์เป็นหนึ่งในการดำเนินการที่หนักกว่าในโมเดลภาษาขนาดใหญ่ ข้อมูลแสดงให้เห็นว่าใน GPU จำนวนมาก กลุ่มย่อยจะเพิ่มความเร็วเป็น 2, 5 หรือ 13 เท่าของเกณฑ์พื้นฐาน อย่างไรก็ตาม ให้สังเกตว่าใน GPU แรกนั้น กลุ่มย่อยไม่ได้ดีไปกว่ามากนัก

วันที่

การเพิ่มประสิทธิภาพ GPU เป็นเรื่องยาก

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

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

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

ในแผนภูมิต่อไปนี้ เราได้ใช้อัลกอริทึมการคูณเมตริกซ์เดียวกัน แต่เพิ่มอีกมิติข้อมูลหนึ่งเพื่อสาธิตผลกระทบของกลยุทธ์การเพิ่มประสิทธิภาพต่างๆ ตลอดจนความซับซ้อนและความแปรปรวนของ GPU ต่างๆ เราแนะนำเทคนิคใหม่ที่นี่ ซึ่งเราจะเรียกว่า "Swizzle" Swizzle ปรับรูปแบบการเข้าถึงหน่วยความจำให้เหมาะกับฮาร์ดแวร์มากที่สุด

คุณจะเห็นได้ว่าความทรงจำที่วุ่นวายสร้างผลกระทบอย่างมาก ในบางครั้งก็สร้างผลกระทบ ได้มากกว่ากลุ่มย่อย ใน GPU 6 ความเร็ว Swizzle จะเพิ่มความเร็วขึ้น 12 เท่า ส่วนกลุ่มย่อยจะมีความเร็วเพิ่มขึ้น 13 เท่า เมื่อพิจารณารวมกันแล้ว ถือว่ามีความเร็วเพิ่มขึ้นถึง 26 เท่า สำหรับ GPU อื่นๆ บางครั้งการรวม Swizzle และกลุ่มย่อยจะมีประสิทธิภาพมากกว่าการใช้เพียงตัวเดียว และใน GPU อื่นๆ การใช้ swizzle เพียงอย่างเดียวจะทำงานได้ดีที่สุด

วันที่

การปรับแต่งและเพิ่มประสิทธิภาพอัลกอริทึม GPU เพื่อให้ทำงานได้ดีกับฮาร์ดแวร์ทุกชิ้นต้องอาศัยความเชี่ยวชาญอย่างมาก แต่โชคดีที่มีผลงานมากมายที่มีความสามารถมากมายที่ใส่เข้ามาในเฟรมเวิร์กของไลบรารีระดับสูงขึ้น เช่น Mediapipe, Transformers.js, Apache TVM, ONNX Runtime Web และอีกมากมาย

ไลบรารีและเฟรมเวิร์กอยู่ในจุดที่เหมาะสมในการจัดการกับความซับซ้อนของการจัดการสถาปัตยกรรม GPU ที่หลากหลาย รวมถึงการสร้างโค้ดเฉพาะแพลตฟอร์มที่จะทำงานได้ดีในไคลเอ็นต์

สรุปประเด็นสำคัญ

ทีม Chrome ยังคงช่วยพัฒนามาตรฐาน WebAssembly และ WebGPU อย่างต่อเนื่องเพื่อปรับปรุงแพลตฟอร์มเว็บสำหรับภาระงานของแมชชีนเลิร์นนิง เราลงทุนกับการประมวลผลพื้นฐานที่รวดเร็วขึ้น การทำงานร่วมกันที่ดีขึ้นสำหรับมาตรฐานเว็บต่างๆ และการตรวจสอบว่าโมเดลทั้งขนาดใหญ่และขนาดเล็กจะทำงานได้อย่างมีประสิทธิภาพในอุปกรณ์ต่างๆ

เป้าหมายของเราคือการเพิ่มขีดความสามารถของแพลตฟอร์มไปพร้อมกับรักษาสิ่งที่ดีที่สุดของเว็บเอาไว้ ซึ่งก็คือการเข้าถึง ความสามารถในการใช้งาน และความสามารถในการถ่ายโอนได้ และเราไม่ได้ทำเช่นนี้เพียงลำพัง เรากำลังทำงานร่วมกับผู้ให้บริการเบราว์เซอร์รายอื่นๆ ที่ W3C และพันธมิตรด้านการพัฒนาจำนวนมาก

หวังว่าคุณจะจำสิ่งต่อไปนี้ได้เมื่อคุณทํางานกับ WebAssembly และ WebGPU

• การอนุมานจาก AI พร้อมใช้งานบนเว็บและในอุปกรณ์ต่างๆ แล้ว ซึ่งใช้ประโยชน์จากการใช้งานอุปกรณ์ไคลเอ็นต์ เช่น ลดต้นทุนด้านเซิร์ฟเวอร์ เวลาในการตอบสนองต่ำ และความเป็นส่วนตัวที่เพิ่มมากขึ้น
• แม้ว่าหลายๆ ฟีเจอร์ที่กล่าวถึงจะเกี่ยวข้องกับผู้เขียนเฟรมเวิร์กเป็นหลัก แต่แอปพลิเคชันของคุณก็ได้รับประโยชน์โดยไม่มีค่าใช้จ่ายมากนัก
• มาตรฐานเว็บมีความคล่องตัวและเปลี่ยนแปลงอยู่ตลอดเวลา และเรารับฟังความคิดเห็นอยู่เสมอ แชร์ข้อมูลของคุณสำหรับ WebAssembly และ WebGPU

กิตติกรรมประกาศ

เราขอขอบคุณทีมกราฟิกเว็บของ Intel ที่มีส่วนสำคัญในการกระตุ้น WebGPU f16 และฟีเจอร์ต่างๆ ของผลิตภัณฑ์แบบจุดจำนวนเต็ม เราขอขอบคุณสมาชิกท่านอื่นๆ ของคณะทำงาน WebAssembly และ WebGPU ที่ W3C รวมถึงผู้ให้บริการเบราว์เซอร์รายอื่นๆ

ขอขอบคุณทีม AI และ ML ทั้งที่ Google และในชุมชนโอเพนซอร์สซึ่งเป็นพาร์ทเนอร์ที่ยอดเยี่ยม และแน่นอนว่าเพื่อนร่วมทีมของเราทุกคนที่ทำให้ทั้งหมดนี้เป็นจริงขึ้นมาได้