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

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

Austin Eng

Deepti Gandluri

François Beaufort

WebGPU

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

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

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

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

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

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

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

WebGPU เหมาะสําหรับโมเดล AI และ ML ซึ่งมีพารามิเตอร์หลายพันล้านรายการ เนื่องจากการรองรับ Compute Shader คอมพิวตเชดเดอร์จะทำงานบน GPU และช่วยดำเนินการกับอาร์เรย์แบบขนานกับข้อมูลจำนวนมาก

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

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

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

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

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

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

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

เมื่อใช้ shader-f16 การทดสอบ WebGPU สำหรับการฝังข้อความของ Hugging Face จะทำการทดสอบได้เร็วกว่า f32 ในแล็ปท็อป Apple M1 Max 3 เท่า

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

ฉันขอให้ WebLLM วางแผนการเดินทางไปปารีสโดยใช้โมเดลพารามิเตอร์ 8, 000 ล้านรายการของ Llama 3 ผลลัพธ์แสดงให้เห็นว่าในช่วงที่กรอกข้อมูลล่วงหน้าของโมเดล 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);
}

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

// 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 รายการเพื่อคำนวณค่าแต่ละค่าในเวกเตอร์เอาต์พุต ซึ่งได้แก่ A, B, C และ D

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

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

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

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

แผนภูมิ 1: การเพิ่มความเร็วของเวกเตอร์เมทริกซ์ โดยเปรียบเทียบ f16 กับ U8 และ U8 ที่มี dot4U8Packed

ตรวจสอบการรองรับเบราว์เซอร์ด้วยพร็อพเพอร์ตี้ wgslLanguageFeatures หาก GPU ไม่รองรับผลิตภัณฑ์จุดแบบแพ็กโดยกำเนิด เบราว์เซอร์จะโพลีฟีลการใช้งานของตัวเอง

// main.js

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

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

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

// 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 ที่เขียนขึ้นเพื่อใช้ผลคูณแบบดอทของจำนวนเต็มแบบแพ็ก ความแตกต่างหลักๆ คือ แทนที่จะโหลดค่า float 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 ของระยะการกรอกข้อมูลล่วงหน้าของโมเดลภาษาขนาดใหญ่ ดังนั้นเราจะรายงานเฉพาะการเร่งความเร็วสำหรับระยะการกรอกข้อมูลล่วงหน้าเท่านั้น ใน GPU ของ Intel เราพบว่ากลุ่มย่อยมีประสิทธิภาพเร็วกว่าพื้นฐาน 2.5 เท่า อย่างไรก็ตาม การปรับปรุงเหล่านี้อาจไม่เหมือนกันสำหรับ GPU แต่ละรุ่น

แผนภูมิ 2. กลุ่มย่อยทําให้ระบบแสดงโฆษณาที่กรอกล่วงหน้าได้เร็วขึ้น 2.5 เท่าใน GPU Intel Tiger Lake GT2 พร้อมการรองรับเวอร์ชันทดลองใน Chrome และ Mediapipe

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

แผนภูมิ 3. การใช้กลุ่มย่อยสำหรับการคูณเมทริกซ์อาจเพิ่มประสิทธิภาพได้

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

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

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

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

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

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

แผนภูมิ 4.

การปรับแต่งและการเพิ่มประสิทธิภาพอัลกอริทึมของ 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 และชุมชนโอเพนซอร์สที่ถือเป็นพาร์ทเนอร์ที่ยอดเยี่ยม และแน่นอน ขอขอบคุณเพื่อนร่วมทีมทุกคนที่ทําให้สิ่งเหล่านี้เกิดขึ้นได้