ภาพถ่ายโดย Deepmind on Unsplash
การคูณเมทริกซ์เป็นการดำเนินการพื้นฐานที่ใช้ในระบบต่างๆ ตั้งแต่โครงข่ายประสาทเทียมไปจนถึงรูทีนการคำนวณทางวิทยาศาสตร์ การค้นหาอัลกอริทึมที่มีประสิทธิภาพและถูกต้องในการพิสูจน์สำหรับการคูณเมทริกซ์สามารถมีผลกระทบอย่างมากต่อการทำให้การคำนวณเร็วขึ้นและมีประสิทธิภาพมากขึ้น แต่เป็นงานที่ท้าทายมาก ช่องว่างของอัลกอริทึมที่เป็นไปได้นั้นมีอยู่มหาศาล และวิธีการดั้งเดิมในการค้นหาอัลกอริทึม เช่น ฮิวริสติกที่ออกแบบโดยมนุษย์หรือการค้นหาเชิงผสม มักไม่ได้ผลเท่าที่ควร
Deepmindโซลูชันที่ใช้ AI ที่นำเสนอเมื่อเร็วๆ นี้สำหรับการค้นหาอัตโนมัตินั้นมีมากกว่าสัญชาตญาณของมนุษย์ โซลูชันนี้ประกอบด้วยตัวแทนการเรียนรู้แบบเสริมกำลังเชิงลึกที่เรียกว่า AlphaTensor ซึ่งสร้างขึ้นจากด้านบน อัลฟาซีโร. เอเจนต์นี้ได้รับการฝึกฝนให้เล่นเกม TensorGame แบบผู้เล่นคนเดียว โดยมีเป้าหมายเพื่อค้นหาอัลกอริทึมที่มีประสิทธิภาพในการคำนวณสำหรับการคูณเมทริกซ์
AlphaTensor นั้นดีเป็นพิเศษในการจัดการเมทริกซ์ขนาดใหญ่โดยการแยกย่อยการคูณเมทริกซ์ขนาดใหญ่เป็นการคูณที่เล็กลง นอกจากนี้ ยังสามารถใช้ AlphaTensor เพื่อให้ได้ประสิทธิภาพที่ล้ำสมัยสำหรับการคูณเมทริกซ์เมื่อปรับแต่งอย่างละเอียดบนอุปกรณ์ฮาร์ดแวร์เฉพาะ
AlphaTensor มีศักยภาพที่ดีในการเร่งการประมวลผลการเรียนรู้เชิงลึก ในการเรียนรู้เชิงลึก การดำเนินการที่ใช้เวลานานจำนวนมากสามารถจับคู่กับการคูณเมทริกซ์ได้ การใช้ AlphaTensor เพื่อเพิ่มประสิทธิภาพการทำงานเหล่านี้ ประสิทธิภาพโดยรวมของโมเดลการเรียนรู้เชิงลึกสามารถปรับปรุงได้อย่างมาก
เมื่อเร็วๆ นี้ OpenAlphaTensor, the การใช้งานโอเพ่นซอร์สครั้งแรกของ AlphaTensorเปิดตัวแล้ว ซึ่งสามารถปฏิวัติพลังการคำนวณของโมเดลการเรียนรู้เชิงลึก
เมทริกซ์คูณเมตริกซ์
สำหรับผู้ที่ไม่เชี่ยวชาญในการเพิ่มประสิทธิภาพการคูณเมทริกซ์ อาจไม่ตรงไปตรงมาที่จะเข้าใจว่าการดำเนินการเช่นการคูณเมทริกซ์สามารถแมปในเทนเซอร์สามมิติได้อย่างไร ฉันจะพยายามอธิบายด้วยคำง่ายๆและตัวอย่าง
ลองพิจารณาผลคูณ C = A*B โดยที่ A และ B เป็นเมทริกซ์กำลังสองขนาด N เพื่อความง่าย การคูณสามารถแมปได้ในเทนเซอร์ของรูปร่าง 3 มิติ (N^2, N^2, N^2) มิติเทนเซอร์แรกแสดงถึงเมทริกซ์ A แบบแบน มิติที่สองคือเมทริกซ์ B แบบแบน และมิติที่สามคือเมทริกซ์แบบแบน C
เทนเซอร์มีค่าเลขฐานสองเท่านั้น (1 หรือ 0) สำหรับแต่ละรายการ โปรดทราบว่าเทนเซอร์เป็นตัวแทนของการดำเนินการคูณ ดังนั้นจึงไม่ขึ้นกับค่าของเมทริกซ์ A และ B
ทุกรายการของเทนเซอร์สอดคล้องกับค่าสัมประสิทธิ์ของการดำเนินการ ตัวอย่างเช่น ในการคำนวณ C[1,1] จำเป็นต้องคูณทั้ง A[1,1] และ B[1,1] ดังนั้น รายการเทนเซอร์ [0,0,0] ซึ่งสอดคล้องกับ A[1,1], B[1,1] และ C[1,1] จะมีค่า 1 ในทางตรงกันข้าม ในการคำนวณ C[1,1 ,2,1], A[1] ไม่จำเป็น ดังนั้น แถวเทนเซอร์ T[N+0, :, XNUMX] จะมีเพียงศูนย์เท่านั้น
ภาพด้านล่างแสดงตัวอย่างเทนเซอร์สำหรับ N=2
ภาพจาก DeepMind's กระดาษ ตีพิมพ์ใน ธรรมชาติ
ดังที่แสดงใน (b) และ (c) ในรูปด้านบน เป็นไปได้ที่จะใช้อัลกอริทึมสำหรับการคำนวณผลิตภัณฑ์โดยใช้การสลายตัวของเทนเซอร์ 3 มิติ โดยเฉพาะอย่างยิ่ง อัลกอริทึมด้านล่างสามารถใช้สำหรับการแปลงการสลายตัวของเทนเซอร์ (เมทริกซ์ U, V, W) เป็นอัลกอริทึมการคูณเมทริกซ์
เมตาอัลกอริธึมที่กำหนดพารามิเตอร์สำหรับการคำนวณผลิตภัณฑ์เมทริกซ์ C=AB ที่นำมาใช้ใน DeepMind กระดาษ
เกมเทนเซอร์
ปัญหาในการค้นหาอัลกอริธึมที่มีประสิทธิภาพสำหรับการคูณเมทริกซ์นั้นเป็นสิ่งที่ท้าทายอย่างยิ่ง เพราะจำนวนของอัลกอริธึมที่เป็นไปได้ที่ต้องพิจารณามีมากกว่าจำนวนอะตอมในเอกภพมาก แม้แต่สำหรับการคูณเมทริกซ์ที่มีขนาดเล็กก็ตาม
DeepMind เปลี่ยนปัญหานี้ให้เป็นเกมสำหรับผู้เล่นคนเดียว และเรียกมันว่า TensorGame ในเกมนี้ ผู้เล่นเลือกวิธีรวมรายการเมทริกซ์ต่างๆ เพื่อคูณพวกเขา คะแนนถูกกำหนดตามจำนวนการดำเนินการที่จำเป็นเพื่อให้ได้ผลลัพธ์การคูณที่ถูกต้อง เกมจะจบลงเมื่อถึงศูนย์เทนเซอร์หรือเมื่อมีการเคลื่อนไหวสูงสุด การแยกตัวประกอบขั้นสุดท้ายได้รับการประเมินตามการประมาณอันดับที่เหลือและเกณฑ์การปรับให้เหมาะสมบางอย่าง เช่น ความซับซ้อนของเวลาเชิงซีมโทติคหรือรันไทม์เชิงปฏิบัติ
ตำแหน่งเริ่มต้นใน TensorGame สอดคล้องกับ Matrix Multiplication Tensor ที่แสดงโดยสุ่ม
ในแต่ละขั้นตอน t ของเกม ผู้เล่นเขียนเวกเตอร์สามตัว
ซึ่งระบุเทนเซอร์อันดับ 1 . สถานะของเกมได้รับการปรับปรุงโดยการลบเวกเตอร์ที่เลือกโดยผู้เล่น:
ที่ไหน
คือเมตริกซ์คูณเมตริกซ์หากเกมจบลงในขั้นตอน p หมายความว่าเมตริกซ์การคูณเมตริกซ์
สามารถแยกย่อยได้เป็น p rank-1 tensors คือมีอันดับ p เป็นอย่างน้อยจากนั้น TensorGame สามารถตีความได้ว่าเป็นอัลกอริทึมการจำแนกอันดับ และ AlphaTensor สามารถถูกมองว่าเป็นอัลกอริทึมสำหรับการประเมินอันดับของเทนเซอร์
สถาปัตยกรรม AlphaTensor
จนถึงตอนนี้ เราได้เรียนรู้เกี่ยวกับ TensorGame และชี้แจงว่าวิธีแก้ไขสามารถมองเป็นอัลกอริทึมการคูณเมทริกซ์ได้อย่างไร ตอนนี้เรามาสำรวจแนวคิดหลักของ AlphaTensor ซึ่งเป็นอัลกอริทึมที่ใช้กับเกม
สถาปัตยกรรม AlphaTensor นั้นเป็นสถาปัตยกรรมตัวเข้ารหัสและตัวถอดรหัส Transformer โดยที่:
- ตัวเข้ารหัสใช้เป็นอินพุตสถานะของเกม , การดำเนินการก่อนหน้า n ครั้งโดยโมเดล (ปกติ n=7) และดัชนีเวลา t ของการกระทำปัจจุบัน ข้อมูลจะเรียงซ้อนกันในรูปเมตริก (n+1, N^2, N^2, N^2) จากนั้นเทนเซอร์นี้จะเปลี่ยนรูปร่างและแปลง (โดยใช้เส้นตรงสามชั้น) ในรูปร่างเทนเซอร์ (N^2, N^2, c) โดยที่ c คือมิติด้านในของแบบจำลอง
- ตัวถอดรหัสสร้างการกระทำ n_steps จากเวกเตอร์แบบฝังที่กำหนดโดยตัวเข้ารหัสในลักษณะถดถอยอัตโนมัติ การกระทำแต่ละอย่างสอดคล้องกับโทเค็นของแฝดสาม เป็นตัวแทนของหนึ่งในแฝดสามที่ย่อยสลายเกมเทนเซอร์ (เช่น ลดอันดับของมัน)
หุ่นจำลองได้รับการฝึกโดยสลับการกลับหลังและการแสดงของหุ่นจำลอง การแสดงโมเดลใช้เพื่อสร้างข้อมูลที่นำไปใช้ในการฝึกโมเดล ในทางปฏิบัติ หุ่นจำลองได้รับการฝึกฝนโดยผสมผสานระหว่างข้อมูลที่สร้างขึ้นโดยสังเคราะห์และข้อมูลที่สร้างโดยโมเดลระหว่างการแสดง ขั้นตอนการแสดงทำได้โดยใช้เทนเซอร์ 3 มิติที่สอดคล้องกับการทำงานของเมทริกซ์และเล่นเกม n_actors นักแสดงแต่ละคนเล่นเกมบนพื้นฐานมาตรฐานหรือบนพื้นฐานทางเลือก (การเปลี่ยนแปลงพื้นฐานจะใช้กับความน่าจะเป็นที่กำหนด) ผลลัพธ์จะถูกรวบรวมและสามารถนำไปใช้ในขั้นตอนการฝึกอบรมด้วยข้อมูลสังเคราะห์
ขั้นตอนการดำเนินการขึ้นอยู่กับ Monte Carlo Tree Search (MCTS) ของ AlphaZero ซึ่งได้รับการแก้ไขเพื่อรองรับพื้นที่การดำเนินการขนาดใหญ่ กล่าวโดยสรุป ก่อนที่จะเลือกการดำเนินการ เส้นทาง n_sims จะถูกสำรวจจากเอาต์พุตของโมเดลโดยมีการสำรวจสูงสุด 5 ขั้นตอนในอนาคต ความน่าจะเป็นที่สร้างโดยแบบจำลองจะถูกปรับโดยคำนึงถึงเส้นทางที่สร้างขึ้น จากนั้นจึงเลือกการกระทำที่มีเส้นทางในอนาคตที่มีแนวโน้มมากที่สุดเพื่อเล่นเกมต่อไป
ในขณะที่ฝึกโมเดล รางวัลเป็นรางวัลเชิงลบ (บทลงโทษ) ค่าสัมบูรณ์จะเพิ่มขึ้นตามแต่ละขั้นตอนที่จำเป็นในการแก้เกม หากโมเดลใช้ขั้นตอน m เพื่อแก้ปัญหา TensorGame รางวัลที่เกี่ยวข้องกับเกมคือ r=-m หากโมเดลไม่สามารถแก้ปัญหา TensorGame ในขั้นตอน max_rank รางวัลจะคำนวณโดยการประมาณอันดับของเทนเซอร์ที่เหลืออยู่ อันดับประมาณเป็นผลรวมของอันดับของเมทริกซ์ที่ประกอบเป็นเทนเซอร์ ค่าประมาณเป็นขอบเขตบนของอันดับที่แท้จริงของเทนเซอร์
เมื่อปรับแต่งโมเดลอย่างละเอียด รางวัลการลงโทษที่สถานะเทอร์มินัลควรคำนึงถึงเวลาแฝงของอัลกอริทึมที่สร้างโดยโมเดลด้วย สูตรการให้รางวัลจะกลายเป็น rt'=rt+ladbt โดยที่ rt คือโครงการการให้รางวัลที่อธิบายไว้ก่อนหน้านี้ bt คือรางวัลเกณฑ์มาตรฐาน (ไม่เป็นศูนย์เฉพาะที่สถานะเทอร์มินัลเท่านั้น) และ λ เป็นค่าสัมประสิทธิ์ที่ผู้ใช้กำหนด
เพิ่มความเร็ว (%) ของอัลกอริธึมที่ค้นพบโดย AlphaTensor ซึ่งปรับแต่งมาสำหรับ GPU และ TPU ซึ่งดึงมาจากกระดาษของ DeepMind การเพิ่มความเร็วจะวัดโดยเทียบกับมาตรฐาน (เช่น cuBLAS สำหรับ GPU) การคูณเมทริกซ์บนฮาร์ดแวร์เดียวกันและเปรียบเทียบกับ อัลกอริทึม Strassen-square. แหล่งที่มา: Deepmind.
ฉันเพิ่งปล่อย โอเพนอัลฟ่าเทนเซอร์การใช้งานโอเพ่นซอร์สครั้งแรกของ AlphaTensor ในส่วนนี้ฉันจะแนะนำการใช้งาน ดังที่เราได้กล่าวไปแล้วก่อนหน้านี้ สถาปัตยกรรม AlphaTensor นั้นค่อนข้างตรงไปตรงมา โดยอ้างอิงจากหม้อแปลงมาตรฐานที่มีสถาปัตยกรรมตัวเข้ารหัส-ตัวถอดรหัส ส่วนประกอบที่น่าสนใจที่สุดของ AlphaTensor คือชั้นแรกในส่วนของตัวเข้ารหัสและวิธีการสุ่มตัวอย่างการทำงาน
เริ่มจากเลเยอร์การเข้ารหัสแรก
# x.size = (N, T, S, S, S)
# scalars.size = (N, s)
batch_size = x.shape[0]
S = x.shape[-1]
T = x.shape[1]
x1 = x.permute(0, 2, 3, 4, 1).reshape(batch_size, S, S, S * T)
x2 = x.permute(0, 4, 2, 3, 1).reshape(batch_size, S, S, S * T)
x3 = x.permute(0, 3, 4, 2, 1).reshape(batch_size, S, S, S * T)
input_list = [x1, x2, x3]
for i in range(3): temp = self.linears_1[i](scalars).reshape(batch_size, S, S, 1) input_list[i] = torch.cat([input_list[i], temp], dim=-1) input_list[i] = self.linears_2[i](input_list[i])
x1, x2, x3 = input_list
ในข้อมูลโค้ดด้านบน เราแสดงวิธีการแยกเทนเซอร์อินพุตออกเป็นสามเทนเซอร์ ซึ่งจากนั้นจะใช้เป็นอินพุตคิวรี คีย์ และค่าของเลเยอร์หม้อแปลง
- ในมิติเทนเซอร์ทั้งสามที่แสดงถึงเมทริกซ์แบบแบน (A, B, C) เทนเซอร์อินพุตจะถูกทำให้แบนตามแต่ละมิติพร้อมกับมิติที่แสดงถึงการกระทำก่อนหน้า ด้วยวิธีนี้ ในแต่ละสำเนาของเทนเซอร์อินพุต มิติที่เลือกเป็นการรวมของค่า T-1 ล่าสุดและค่าจริง สำหรับค่า S ทั้งหมดของมิติที่เลือก โดยที่ S=N^2 ในทางปรัชญา เหมือนกับว่าในแต่ละมิติ เราโฟกัสไปที่สิ่งที่เกิดขึ้นในการกระทำก่อนหน้าในมิตินั้น
- สเกลาร์ถูกแมปในช่องว่างสามส่วนที่แตกต่างกันของมิติ S^2 จากนั้นเปลี่ยนรูปร่างใหม่เพื่อเชื่อมกับเทนเซอร์ที่ได้มาจากจุดก่อนหน้า ตามแนวคิด สเกลาร์จะถูกแมปกับพื้นที่การฝังของมิติ S^2 จากนั้นข้อมูลที่ฝังจะถูกแยกออกเป็นเวกเตอร์ S และเรียงซ้อนกัน คล้ายกับสิ่งที่เกิดขึ้นกับข้อความเมื่อทำโทเค็น
- โทเค็นสเกลาร์เชื่อมกับเทนเซอร์อินพุตที่ปรับโครงสร้างแล้ว จากนั้นให้เป็นอินพุตไปยังเลเยอร์เชิงเส้นสำหรับแมปข้อมูลสเกลาร์+แชนเนล-ประวัติโฟกัสในมิติภายในของโมเดล
สามขั้นตอนนี้สามารถตีความได้ว่าเป็นวิธีการให้ข้อมูลแก่โมเดลทั้งเกี่ยวกับสเกลาร์ (เช่นเดียวกับขั้นตอนเวลา TensorGame) และการมุ่งเน้นที่การดำเนินการก่อนหน้าสำหรับแต่ละแชนเนล
เกี่ยวกับวิธีการสร้างการกระทำ เป็นที่น่าสนใจที่จะทราบว่า AlphaTensor สร้างเป็นเอาต์พุตของ triplet u, v, w ซึ่งมีจุดมุ่งหมายเพื่อลดอันดับเทนเซอร์ เวกเตอร์ทั้งสามตัวมีขนาด S และเนื่องจากนำมาต่อกัน โมเดลจึงต้องสร้างเวกเตอร์ขนาด 3*S AlphaTensor ได้รับการฝึกด้วยอัลกอริทึม RL ดังนั้นการกระทำที่เป็นไปได้ทั้งหมดจะต้องแสดงออกมาในรูปของความน่าจะเป็นในพื้นที่แจกแจง กล่าวคือ โมเดลสร้างความน่าจะเป็นเหนือการกระทำต่างๆ ซึ่งหมายความว่าเวกเตอร์แต่ละตัวในพื้นที่ 3S ควรถูกแมปกับการกระทำที่แตกต่างกัน ซึ่งส่งผลให้พื้นที่การดำเนินการขนาด |F|^(3S) โดยที่ |F| คือจำนวนค่าต่างๆ ที่สมาชิกของ u, v, w สามารถรับได้ โดยปกติแล้ว ค่าต่างๆ จะถูกจำกัดไว้ที่ (-2, -1, 0, 1, 2) ซึ่งส่งผลให้มีจำนวนองค์ประกอบ 5 องค์ประกอบ
ความท้าทายที่สำคัญมาถึงแล้ว: เพื่อสร้างความน่าจะเป็นในการดำเนินการสำหรับผลคูณเมทริกซ์ของเมทริกซ์ขนาด 5 เราจำเป็นต้องมีหน่วยความจำ 5^75 * 4 ไบต์ ซึ่งหมายถึงหน่วยความจำประมาณ 10^44 GB เห็นได้ชัดว่าเราไม่สามารถจัดการพื้นที่ดำเนินการขนาดใหญ่เช่นนี้ได้
เราจะแก้ปัญหาอย่างไร? เพื่อลดรอยเท้าหน่วยความจำของความน่าจะเป็นของการกระทำ เราสามารถแยกแฝดสามออกเป็นชิ้นเล็ก ๆ "โทเค็น" พวกมัน และปฏิบัติต่อชิ้นเป็นโทเค็นที่สร้างขึ้นในสถาปัตยกรรมหม้อแปลง กล่าวคือ โทเค็นจะถูกป้อนเป็นอินพุตให้กับตัวถอดรหัสในการถดถอยอัตโนมัติ ทาง. ในตัวอย่างด้านบน เราสามารถแบ่งแฝดสามออกเป็น 15 ชิ้น ลดการใช้หน่วยความจำลงเหลือ 15 * 5^(75/15) * 4 คือ 187.5 KB
def _eval_forward(self, e: torch.Tensor): bs = e.shape[0] future_g = ( torch.zeros((bs, self.n_samples, self.n_steps)).long().to(e.device) ) ps = torch.ones((bs, self.n_samples)).to(e.device) e = e.unsqueeze(1).repeat(1, self.n_samples, 1, 1) future_g = future_g.view(-1, self.n_steps) ps = ps.view(-1) e = e.view(-1, e.shape[-2], e.shape[-1]) for i in range(self.n_steps): o_s, z_s = self.core(future_g[:, : i + 1], e) future_g[:, i], p_i = sample_from_logits(o_s[:, i]) ps *= p_i future_g = future_g.view(bs, self.n_samples, self.n_steps) ps = ps.view(bs, self.n_samples) return ( future_g, ps, z_s[:, 0].view(bs, self.n_samples, *z_s.shape[2:]).mean(1), )
ด้านบนเราแสดงข้อมูลโค้ดสำหรับสร้างการดำเนินการทั้งหมด ในรหัส self.core มีเลเยอร์ตัวถอดรหัสและเทนเซอร์ e แทนเอาต์พุตของเลเยอร์ตัวเข้ารหัส ศูนย์ถือได้ว่าเป็น โทเค็นในโมเดล NLP และการดำเนินการ n_steps ที่เป็นตัวแทนของ n_steps chunks จะถูกสร้างขึ้นในลักษณะที่ก้าวหน้า
โมเดลส่งคืนปริมาณสามค่า:
- การกระทำที่สร้างขึ้น
- ความน่าจะเป็นที่เกี่ยวข้องกับการดำเนินการทั้งหมด
- บันทึกที่สร้างขึ้นสำหรับการสร้างการดำเนินการแรก (กลุ่มแรก) ที่จะใช้สำหรับการคำนวณค่าแบบจำลอง
ควรใช้คำสองสามคำกับพารามิเตอร์ n_samples พารามิเตอร์นี้ใช้สำหรับขั้นตอนการแสดงและช่วยให้แบบจำลองสร้างรุ่นต่างๆ ของแฝดสาม ซึ่งจะใช้สำหรับการสำรวจพื้นที่ดำเนินการในอัลกอริทึมการค้นหาต้นไม้มอนติคาร์โลที่ใช้ในกระบวนการแสดง การดำเนินการต่างๆ ของ n_samples จะถูกสุ่มตัวอย่างตามนโยบายที่สร้างโดยโมเดล
ขั้นตอนการแสดง
ส่วนที่ยุ่งยากที่สุดของอัลกอริทึมทั้งหมดน่าจะเป็นขั้นตอนการแสดงที่ใช้ในการแก้ปัญหา TensorGame อัลกอริทึมไม่ได้อธิบายอย่างลึกซึ้งในเอกสาร AlphaTensor เนื่องจากอ้างอิงจากเอกสารก่อนหน้าของ DeepMind หลายฉบับซึ่งเพิ่งถูกอ้างถึงและระบุตามที่ทราบ ที่นี่ ฉันจะสร้างชิ้นส่วนที่ขาดหายไปทั้งหมดขึ้นมาใหม่และอธิบายทีละขั้นตอนเกี่ยวกับการใช้งานของเรา
เราสามารถจัดขั้นตอนการแสดงออกเป็นสามส่วน:
- การค้นหาต้นไม้มอนติคาร์โล
- การจำลองเกม
- การคำนวณนโยบายที่ได้รับการปรับปรุง
ให้เราวิเคราะห์ทีละรายการ
การค้นหาต้นไม้มอนติคาร์โล (MCTS)
Monte Carlo Tree Search (MCTS) เป็นเทคนิคปัญญาประดิษฐ์ที่ใช้กันอย่างแพร่หลายสำหรับการเล่นเกม โดยเฉพาะอย่างยิ่งในเกมกระดานและวิดีโอเกม อัลกอริทึมสร้างแผนภูมิเกมที่จำลองการเคลื่อนไหวและผลลัพธ์ที่เป็นไปได้ และใช้การสุ่มตัวอย่างเพื่อประเมินรางวัลที่คาดหวังสำหรับแต่ละการเคลื่อนไหว จากนั้นอัลกอริทึมจะเลือกการเคลื่อนไหวซ้ำๆ ด้วยรางวัลที่คาดหวังสูงสุด และจำลองผลลัพธ์จนกว่าจะถึงสถานะปลายทางหรือเงื่อนไขการหยุดที่ระบุ การจำลองจะใช้เพื่อประเมินความน่าจะเป็นที่จะชนะในแต่ละการเคลื่อนไหวและเป็นแนวทางในกระบวนการตัดสินใจ MCTS ได้รับการพิสูจน์แล้วว่ามีประสิทธิภาพในเกมที่ซับซ้อนซึ่งจำนวนการเคลื่อนไหวที่เป็นไปได้และผลลัพธ์มีจำนวนมาก และถูกนำมาใช้ในระบบ AI การเล่นเกมที่ประสบความสำเร็จ เช่น AlphaGo
ใน AlphaTensor จะใช้เวอร์ชันแก้ไขของ MCTS ดั้งเดิม โดยเฉพาะอย่างยิ่ง แทนที่จะสุ่มเลือกการกระทำจากพื้นที่การกระทำทั้งหมด การกระทำนั้นจะถูกเลือกจากชุดย่อยที่สร้างโดยตรงจากแบบจำลอง (ผ่าน n_samples ที่นำเสนอก่อนหน้านี้) การแก้ไขการอัปเกรดนโยบายจะถูกนำไปใช้ในขั้นตอนการคำนวณนโยบายที่ปรับปรุงแล้ว
ในการดำเนินการของเรา เราตัดสินใจที่จะเก็บข้อมูลทั้งหมดเกี่ยวกับต้นไม้มอนติคาร์โลไว้ในพจนานุกรมโดยมีสถานะ TensorGame เวอร์ชันแฮชเป็นคีย์ และเป็นค่าของข้อมูลที่เกี่ยวข้องกับสถานะนั้น แต่ละขั้นตอนของ Monte-Carlo เริ่มจากโหนดและจำลองมินิเกม n_sim สำรวจอนาคตด้วยการเคลื่อนไหว 5 ครั้ง หากโหนดได้รับการสำรวจแล้วในการจำลองครั้งก่อน n_sim จะถูกปรับโดยพิจารณาจากจำนวนการสำรวจครั้งก่อน สำหรับแต่ละโหนด จำนวนการเข้าชมจะถูกเก็บไว้ใน N_s_a tensor เนื่องจากเทนเซอร์นี้ประกอบด้วยจำนวนการเข้าชมต่อการดำเนินการย่อยของโหนด (ในจำนวนที่สุ่มตัวอย่างโดยโมเดล)
def monte_carlo_tree_search( model: torch.nn.Module, state: torch.Tensor, n_sim: int, t_time: int, n_steps: int, game_tree: Dict, state_dict: Dict,
): """Runs the monte carlo tree search algorithm. Args: model (torch.nn.Module): The model to use for the simulation. state (torch.Tensor): The initial state. n_sim (int): The number of simulations to run. t_time (int): The current time step. n_steps (int): The maximum number of steps to simulate. game_tree (Dict): The game tree. state_dict (Dict): The dictionary containing the states. """ state_hash = to_hash(extract_present_state(state)) if state_hash in state_dict: with torch.no_grad(): N_s_a = state_dict[state_hash][3] n_sim -= int(N_s_a.sum()) n_sim = max(n_sim, 0) for _ in range(n_sim): simulate_game(model, state, t_time, n_steps, game_tree, state_dict) # return next state possible_states_dict, _, repetitions, N_s_a, q_values, _ = state_dict[ state_hash ] possible_states = _recompose_possible_states(possible_states_dict) next_state_idx = select_future_state( possible_states, q_values, N_s_a, repetitions, return_idx=True ) next_state = possible_states[next_state_idx] return next_state
รหัสด้านบนแสดงการใช้งานอัลกอริทึมของเรา เพื่อความง่ายของโค้ด การแก้ไขนโยบายจะดำเนินการในฟังก์ชัน simulator_game
เกมจำลองสถานการณ์
ฟังก์ชัน Simulator_game มีหน้าที่สำรวจแผนผังที่ประกอบด้วยโหนดที่แสดงสถานะเฉพาะของ TensorGame นอกจากนี้ยังรันโมเดลเมื่อใดก็ตามที่พบโหนดลีฟและเก็บข้อมูลโหนดทั้งหมดในพจนานุกรม state_dict มาดูการนำไปใช้อย่างลึกซึ้งกัน:
@torch.no_grad()
def simulate_game( model, state: torch.Tensor, t_time: int, max_steps: int, game_tree: Dict, states_dict: Dict, horizon: int = 5,
): """Simulates a game from a given state. Args: model: The model to use for the simulation. state (torch.Tensor): The initial state. t_time (int): The current time step. max_steps (int): The maximum number of steps to simulate. game_tree (Dict): The game tree. states_dict (Dict): The states dictionary. horizon (int): The horizon to use for the simulation. """ idx = t_time max_steps = min(max_steps, t_time + horizon) state_hash = to_hash(extract_present_state(state)) trajectory = [] # selection while state_hash in game_tree: ( possible_states_dict, old_idx_to_new_idx, repetition_map, N_s_a, q_values, actions, ) = states_dict[state_hash] possible_states = _recompose_possible_states(possible_states_dict) state_idx = select_future_state( possible_states, q_values, N_s_a, repetition_map, return_idx=True ) trajectory.append((state_hash, state_idx)) # state_hash, action_idx future_state = extract_present_state(possible_states[state_idx]) state = possible_states[state_idx] state_hash = to_hash(future_state) idx += 1 # expansion if idx = max_steps: trajectory.append((state_hash, None)) if not game_is_finished(extract_present_state(state)): state = state.to(model.device) scalars = get_scalars(state, idx).to(state.device) actions, probs, q_values = model(state, scalars) ( possible_states, cloned_idx_to_idx, repetitions, not_dupl_indexes, ) = extract_children_states_from_actions( state, actions, ) not_dupl_actions = actions[:, not_dupl_indexes].to("cpu") not_dupl_q_values = torch.zeros(not_dupl_actions.shape[:-1]).to( "cpu" ) N_s_a = torch.zeros_like(not_dupl_q_values).to("cpu") present_state = extract_present_state(state) states_dict[to_hash(present_state)] = ( _reduce_memory_consumption_before_storing(possible_states), cloned_idx_to_idx, repetitions, N_s_a, not_dupl_q_values, not_dupl_actions, ) game_tree[to_hash(present_state)] = [ to_hash(extract_present_state(fut_state)) for fut_state in possible_states ] leaf_q_value = q_values else: leaf_q_value = -int(torch.linalg.matrix_rank(state).sum()) # backup backward_pass(trajectory, states_dict, leaf_q_value=leaf_q_value)
แต่ละแบบจำลองแบ่งออกเป็นสามส่วน:
- การเลือก
- การขยายตัว
- สำรอง
ในส่วนของการเลือก การจำลองจะทำงานบนโหนดต้นไม้ที่สร้างไว้แล้ว และโหนดต่อไปนี้ถูกเลือกโดยใช้ฟังก์ชันต่อไปนี้:
def select_future_state( possible_states: List[torch.Tensor], q_values: torch.Tensor, N_s_a: torch.Tensor, repetitions: Dict[int, list], c_1: float = 1.25, c_2: float = 19652, return_idx: bool = False,
) -> torch.Tensor: """Select the future state maximizing the upper confidence bound."""
# q_values (1, K, 1) pi = torch.tensor( [ len(repetitions[i]) for i in range(len(possible_states)) if i in repetitions ] ).to(q_values.device) ucb = q_values.reshape(-1) + pi * torch.sqrt( torch.sum(N_s_a) / (1 + N_s_a) ) * (c_1 + torch.log((torch.sum(N_s_a) + c_2 + 1) / c_2)) if return_idx: return ucb.argmax() return possible_states[ucb.argmax()]
ในทางปฏิบัติ การดำเนินการเพิ่มฟังก์ชัน ucb ให้สูงสุด:
สำหรับสถานะที่กำหนดจะถูกเลือก ในที่นี้ Q แทนค่า Q ที่สร้างโดยโมเดล และ π แทนการแจกแจงแบบสุ่มในการดำเนินการที่สุ่มตัวอย่างโดยใช้นโยบายโมเดล N(s, a) แสดงถึงจำนวนการเข้าชมของโหนดเพื่อดำเนินการ a จากโหนด s
เมื่อขั้นตอนการเลือกมาถึงโหนดลีฟ หากการจำลองยังไม่ถึงเงื่อนไขปลายทาง (ในแง่ของการสำรวจสูงสุด เช่น ขอบฟ้าในอนาคต หรือการสิ้นสุดเกม) แบบจำลองจะถูกใช้เพื่อเลือกโหนดทางเลือก n_samples (โหนดเหล่านี้จะเป็นโหนดย่อย โหนดในการวนซ้ำต่อเนื่อง) สิ่งนี้เรียกว่าเฟสการขยาย เนื่องจากโหนดใหม่ถูกเพิ่มเข้าไปในแผนผัง จากนั้น จะไม่มีการสำรวจโหนดเพิ่มเติมในการจำลองปัจจุบัน แต่ leaf q_value จะถูกส่งไปยังขั้นตอนการจำลองต่อไปนี้: การสำรองข้อมูล
การสำรองข้อมูลเป็นขั้นตอนสุดท้ายของแต่ละการจำลอง ระหว่างการสำรองข้อมูล หากโหนดลีฟเป็นสถานะเทอร์มินัล ระบบจะคำนวณรางวัลสุดท้าย มิฉะนั้นจะใช้ค่า leaf q เป็นรางวัลโดยประมาณ จากนั้นรางวัลจะถูกส่งกลับบนวิถีการจำลองที่อัปเดตทั้งสถานะ q_values และอัปเดตตัวนับการเยี่ยมชม N(s, a) ในตัวอย่างด้านล่าง เราแสดงรหัสสำหรับการเผยแพร่กลับของรางวัล
def backward_pass(trajectory, states_dict, leaf_q_value: torch.Tensor): """Backward pass of the montecarlo algorithm"""
reward = 0 for idx, (state, action_idx) in enumerate(reversed(trajectory)): if action_idx is None: # leaf node reward += leaf_q_value else: ( _, old_idx_to_new_idx, _, N_s_a, q_values, _, ) = states_dict[state] if isinstance(reward, torch.Tensor): reward = reward.to(q_values.device) action_idx = int(action_idx) if action_idx in old_idx_to_new_idx: not_dupl_index = old_idx_to_new_idx[int(action_idx)] else: not_dupl_index = action_idx reward -= 1 q_values[:, not_dupl_index] = ( N_s_a[:, not_dupl_index] * q_values[:, not_dupl_index] + reward ) / (N_s_a[:, not_dupl_index] + 1) N_s_a[:, not_dupl_index] += 1
การคำนวณนโยบายที่ได้รับการปรับปรุง
เมื่อมีการเรียกใช้การจำลองทั้งหมดและ MCTS นำเสนอสแน็ปช็อตที่น่าสนใจในอนาคตอันใกล้ ก็ถึงเวลาอัปเดตนโยบายที่เกี่ยวข้องกับโหนดที่คาดการณ์ไว้และส่งคืนโหนดเหล่านั้น เพื่อให้สามารถใช้ระหว่างการฝึกอบรมได้ นโยบายที่ได้รับการปรับปรุงตามวิธีการที่อธิบายไว้ใน ฮิวเบิร์ต และคณะใช้สำหรับจัดการพื้นที่ดำเนินการขนาดใหญ่ อันที่จริง สำหรับพื้นที่การค้นหาขนาดเล็ก เป็นไปได้ระหว่าง MCTS เพื่อสุ่มตัวอย่างการดำเนินการจากพื้นที่ดำเนินการและประเมินผลกระทบ แนวทางที่คล้ายกันในพื้นที่การดำเนินการที่ใหญ่กว่ามากจะนำไปสู่เส้นทางการเคลื่อนที่ทั้งหมดที่แตกต่างกันในเส้นทางต่างๆ และจะต้องมีเส้นทางการเคลื่อนที่จำนวนไม่สิ้นสุดเพื่อรับสถิติที่มีความหมาย จากนั้นจึงอัปเดตนโยบาย เนื่องจากที่นี่เราใช้ MCTS ตัวอย่างเพื่อหลีกเลี่ยงการกระจาย กล่าวคือ การดำเนินการ n_samples จะถูกสุ่มตัวอย่างตามนโยบายแบบจำลอง จากนั้น MCTS จะเลือกหนึ่งในการดำเนินการที่สุ่มตัวอย่างในขณะที่สำรวจแผนผัง เราจำเป็นต้องคำนึงถึงการแก้ไขตัวอย่างเมื่อคำนวณ นโยบายที่อัปเดตขั้นสุดท้ายที่จะใช้ในขณะที่ฝึกโมเดล
ในทางปฏิบัติ นโยบายที่ปรับปรุงแล้วจะคำนวณเป็น
ที่ไหน
def compute_improved_policy( state_dict: Dict, states: List[str], model_n_steps: int, model_n_logits: int, N_bar: int,
): """Compute the improved policy given the state_dict, the list of states. The improved policy is computed as (N_s_a / N_s_a.sum())^(1/tau) where tau is (log(N_s_a.sum()) / log(N_bar)) if N_s_a.sum() > N_bar else 1. """ policies = torch.zeros(len(states), model_n_steps, model_n_logits) N_bar = torch.tensor(N_bar) for idx, state in enumerate(states): N_s_a = state_dict[state][3] actions = state_dict[state][5] if N_s_a.sum() > N_bar: tau = (torch.log(N_s_a.sum()) / torch.log(N_bar)).item() else: tau = 1 N_s_a = N_s_a ** (1 / tau) improved_policy = N_s_a / N_s_a.sum() for sample_id in range(actions.shape[1]): action_ids = actions[0, sample_id] for step_id, action_id in enumerate(action_ids): policies[idx, step_id, action_id] += improved_policy[ 0, sample_id ] return policies
โปรดทราบว่าในการดำเนินการของเราหลังจากคำนวณนโยบายจากเทนเซอร์ N_s_a แล้ว เราต้องแมปกลับกับเทนเซอร์การดำเนินการดั้งเดิม ในความเป็นจริง N_s_a จะพิจารณาการกระทำที่สุ่มตัวอย่างโดยโมเดลเท่านั้น ในขณะที่นโยบายขั้นสุดท้ายจะต้องมีความน่าจะเป็นสำหรับการกระทำที่ไม่ได้สำรวจด้วย
ความแตกต่างเกี่ยวกับอัลกอริทึมการฝึกอบรม ChatGPT
AlphaTensor เป็นสมาชิกล่าสุดของกลุ่มวิธีปัญญาประดิษฐ์ AlphaGo/AlphaZero โดย DeepMind วิธีการเหล่านี้ใช้อัลกอริทึม Monte Carlo Tree Search (MCTS) ซึ่งได้รับการปรับปรุงและปรับปรุงโดย DeepMind เพื่อจัดการกับงานที่ซับซ้อนมากขึ้น ระบบ AI อีกระบบหนึ่งคือ ChatGPT ของ OpenAI ซึ่งสร้างกระแสฮือฮาอย่างมากจากประสิทธิภาพอันน่าทึ่ง ได้รับการฝึกฝนด้วยแนวทางที่แตกต่างออกไป ที่เรียกว่าการเรียนรู้แบบเสริมแรงด้วยผลตอบรับของมนุษย์ (RLHF)
RLHF เป็นเทคนิคการปรับแต่งอย่างละเอียดที่ใช้ในการปรับแต่งโมเดลภาษาให้เป็นไปตามชุดคำสั่งที่เป็นลายลักษณ์อักษร มันใช้ความชอบของมนุษย์เป็นสัญญาณให้รางวัลในการปรับโมเดลอย่างละเอียด ดังนั้นการปรับพฤติกรรมของโมเดลภาษาให้สอดคล้องกับความชอบที่ระบุไว้ของกลุ่มคนที่เฉพาะเจาะจง แทนที่จะเป็นแนวคิดกว้างๆ เกี่ยวกับ 'คุณค่าของมนุษย์'
ในทางตรงกันข้าม MCTS เป็นอัลกอริทึมการค้นหาแบบต้นไม้ที่ใช้ในการกำหนดการเคลื่อนไหวที่เหมาะสมที่สุดในเกม มันจำลองการเคลื่อนไหวที่เป็นไปได้และอัปเดตค่าของการเคลื่อนไหวแต่ละครั้งตามผลลัพธ์ เป็นแนวทางในการเลือกการเคลื่อนไหวที่ดีที่สุด
RLHF รวบรวมข้อมูลจากการสาธิตที่เขียนโดยมนุษย์และการเปรียบเทียบโดยมนุษย์ระหว่างโมเดล AI และฝึกโมเดลรางวัลเพื่อทำนายความชอบของกลุ่มบุคคลที่กำหนด จากนั้นโมเดลรางวัลจะถูกใช้เพื่อปรับแต่งโมเดล AI อย่างละเอียด ในทางกลับกัน MCTS ใช้การจำลองและการประเมินเพื่อตัดสินการตัดสินใจที่ดีที่สุด
แม้ว่าจะเป็นแนวทางที่แตกต่างกัน แต่ RLHF และ MCTS ก็มีความคล้ายคลึงกันเช่นกัน เทคนิคปัญญาประดิษฐ์ทั้งสองใช้วิธีตัดสินใจและแก้ปัญหา และทั้งสองใช้วิธีลองผิดลองถูกเพื่อสำรวจตัวเลือกต่างๆ และตัดสินใจตามข้อมูลที่มีอยู่ ทั้งสองอย่างนี้ยังเป็นกระบวนการที่เกิดซ้ำซึ่งปรับปรุงเมื่อเวลาผ่านไปเมื่อมีการรวบรวมข้อมูลและประสบการณ์มากขึ้น
ทางเลือกระหว่าง RLHF และ MCTS ขึ้นอยู่กับงานที่ทำอยู่ RLHF เหมาะอย่างยิ่งเมื่อไม่มีเมตริกที่ชัดเจนสำหรับการประเมินประสิทธิภาพของโมเดล ในขณะที่ MCTS ได้รับการพิสูจน์แล้วว่ามีประสิทธิภาพในงานที่เหมือนเกม ซึ่งความรู้และการสำรวจอนาคตทำให้โมเดลมีข้อได้เปรียบอย่างมาก
การเพิ่มประสิทธิภาพโค้ดสำหรับการฝึกอบรม AlphaTensor
การนำอัลกอริทึมการฝึก AlphaTensor ไปใช้จำเป็นต้องค้นหาจุดประนีประนอมที่สมบูรณ์แบบระหว่างความเร็วในการฝึกและการใช้หน่วยความจำ ดังที่เห็นในส่วนโมเดล การพิจารณาเพียงแค่การใช้โทเค็นการดำเนินการสามารถประหยัดหน่วยความจำได้มาก แต่การลดพื้นที่ดำเนินการมากเกินไปอาจทำให้ความแม่นยำลดลงและประสิทธิภาพการทำงานช้าลง สิ่งหลังเกิดขึ้นเนื่องจากโทเค็นทั้งหมดถูกสร้างขึ้นตามลำดับโดยตัวถอดรหัสโมเดลโดยอัตโนมัติ ดังนั้น เวลาในการอนุมานจึงเพิ่มขึ้นเป็นเชิงเส้นกับจำนวนโทเค็นต่อการดำเนินการ เมื่อ softmax บนพื้นที่การดำเนินการไม่ใช่คอขวดอีกต่อไป
เมื่อตั้งค่าการฝึกอบรม AlphaTensor ปัญหาหลักๆ ที่พบคือการจัดการกับกระบวนการแสดง หากเทนเซอร์ไม่ได้จัดเก็บในรูปแบบที่ถูกต้อง MCTS อาจทำให้การใช้งานหน่วยความจำเพิ่มขึ้นอย่างควบคุมไม่ได้ ในทางกลับกัน หากจำนวนเทนเซอร์ที่เก็บไว้ระหว่างการจำลองแต่ละครั้งลดลงมากเกินไป MCTS สามารถใช้เวลาไม่จำกัดในการคำนวณสถานะที่ต้องการอีกครั้ง
มาดูตัวอย่างขั้นตอนการจำลองเกมกัน โดยมีการสำรวจเกมโดยพิจารณาจากสถานการณ์ที่เป็นไปได้ในอนาคต สำหรับแต่ละรัฐ หากเราไม่บันทึกการดำเนินการที่สร้างโดยแบบจำลอง และเราตัดสินใจที่จะบันทึกเฉพาะข้อมูลเริ่มต้นแบบสุ่มที่ใช้ในการสุ่มตัวอย่างการดำเนินการจากนโยบาย แต่ละครั้งที่เราสำรวจโหนดแผนผัง เราจะต้องคำนวณนโยบายใหม่และ จากนั้นจึงสุ่มตัวอย่างการกระทำ เห็นได้ชัดว่าเราตัดสินใจจัดเก็บการดำเนินการตัวอย่างเพื่อประหยัดเวลาและเพื่อหลีกเลี่ยงการจัดการการแชร์แบบจำลองระหว่างกระบวนการต่างๆ ในกรณีที่มีการสำรวจ MCTS แบบคู่ขนาน อย่างไรก็ตาม เพียงแค่บันทึกการกระทำนั้นไม่เพียงพอที่จะได้ขั้นตอนการแสดงที่มีประสิทธิภาพเพียงพอ ในความเป็นจริง เวลาในการแปลงการกระทำ n_steps เป็นแฝด (u, v, w) การลดสถานะเทนเซอร์ของเกมและการสร้างเทนเซอร์ 3 มิติใหม่จากการกระทำ n_samples อาจเป็นคอขวดสำหรับการฝึกอบรมทั้งหมดได้อย่างง่ายดาย ประการที่สอง เราไม่ต้องการจัดเก็บสถานะในอนาคตที่เป็นไปได้ทั้งหมดสำหรับการดำเนินการสุ่มตัวอย่างแต่ละครั้ง เนื่องจากการดำเนินการนี้จะมีผลกระทบอย่างมากต่อหน่วยความจำที่ใช้โดยอัลกอริทึม สมมติว่าเราตั้งค่า n_samples=32, n=7 และ N=5 และจำไว้ว่า N คือขนาดของผลคูณเมทริกซ์จตุรัสที่เราต้องการลด และ n คือจำนวนการกระทำก่อนหน้านี้ที่แบบจำลองจำได้ ในสถานการณ์เช่นนี้ เมตริกเทนเซอร์แต่ละตัวจะมีรูปแบบ (8, 25, 25, 25) ซึ่งคูณด้วย 32 จะได้ผลลัพธ์เป็น 3282525254 ไบต์สำหรับแต่ละโหนดในกราฟ ตอนนี้ เมื่อพิจารณาว่าแต่ละการจำลองในเฟสขยายสร้างโหนดใหม่ (และ n_sim=200) เราจะมีการใช้หน่วยความจำสุดท้ายที่ 200328252525*4 = 3.2GB สำหรับโหนด MCTS แรกเพียงอย่างเดียว ในกรณีที่เลวร้ายที่สุด ขณะสำรวจโหนด max_rank (โดยที่ max_rank=150) จะส่งผลให้มีการใช้หน่วยความจำทั้งหมด 150 * 3.2GB = 480GB ในหน่วยความจำ RAM (หรือหน่วยความจำ GPU หากเทนเซอร์ทั้งหมดถูกเก็บไว้ใน GPU) . เราดำเนินการฝึกอบรมบนเวิร์กสเตชันของเราซึ่งมี RAM ขนาด 128 GB และหน่วยความจำ GPU ขนาด 48 GB ดังนั้นเราจึงต้องลดการใช้หน่วยความจำลง
เนื่องจากเราไม่ต้องการเพิ่มเวลาดำเนินการ เราจึงนำการปรับให้เหมาะสมมาใช้ซึ่งใช้ประโยชน์จากความซ้ำซ้อนในเทนเซอร์สถานะที่สร้างขึ้น ในความเป็นจริง เทนเซอร์มีการกระทำที่เหมือนกันก่อนหน้านี้ n-1 ซึ่งสามารถเก็บไว้ได้เพียงครั้งเดียว และไม่ทำซ้ำสำหรับเทนเซอร์แต่ละตัวที่เก็บไว้ ส่งผลให้หน่วยความจำลดลง 2/7~28% ซึ่งหมายความว่าในกรณีที่เลวร้ายที่สุดสามารถจัดเก็บได้ 137GB ณ จุดนี้ เพียงตัดส่วนที่ไม่ได้ใช้ของแผนผัง (เช่น วิถีที่ไม่ได้เลือก) และจัดเก็บเทนเซอร์ไว้ในหน่วยความจำ CPU เราก็สามารถหลีกเลี่ยงข้อผิดพลาดของหน่วยความจำระหว่างการฝึกได้
เมื่อ OpenAlphaTensor เป็นโอเพ่นซอร์สแล้ว ช่องทางที่น่าตื่นเต้นมากมายสำหรับการพัฒนาเพิ่มเติมจึงเปิดขึ้น
ความก้าวหน้าตามธรรมชาติคือการปรับแต่ง OpenAlphaTensor อย่างละเอียดบนอุปกรณ์ฮาร์ดแวร์เป้าหมาย สิ่งนี้คาดว่าจะนำไปสู่ประสิทธิภาพการคำนวณที่แข่งขันได้สูง ฉันจะเผยแพร่เพิ่มเติมเกี่ยวกับประสิทธิภาพของ OpenAlphaTensor บนฮาร์ดแวร์ต่างๆ GitHub. ในขณะที่เขียนบทความนี้ OpenAlphaTensor อยู่ระหว่างการฝึกอบรม
ความก้าวหน้าที่สำคัญอีกประการหนึ่งคือการสนับสนุนการคอมไพล์ระยะไกล ซึ่งช่วยให้ผู้ใช้สามารถสร้างอัลกอริทึมที่ปรับให้เหมาะกับอุปกรณ์เอดจ์ได้ ซึ่งสามารถทำได้โดยจัดเก็บโมเดล OpenAlphaTensor ไว้บนเซิร์ฟเวอร์ ในขณะที่อัลกอริธึมการคูณเมทริกซ์ได้รับการประเมินบนฮาร์ดแวร์ต่างๆ
การขยายการสนับสนุนสำหรับคอมไพเลอร์ที่แตกต่างกันอาจเป็นสิ่งสำคัญเช่นกัน เพื่อคำนวณการแก้ไขรางวัลตามเวลาแฝง คอมไพเลอร์ที่แตกต่างกันสามารถนำไปสู่อัลกอริทึมที่ปรับให้เหมาะสมต่างกันบนฮาร์ดแวร์ที่กำหนด ตัวอย่างเช่น กระดาษ DeepMind แสดงผลลัพธ์ที่น่าพึงพอใจโดยใช้ JAX และคอมไพเลอร์ XLA บน GPU TPU และ Nvidia เป็นเรื่องที่น่าสนใจที่จะประเมินสิ่งนี้โดยใช้ NCCL บน Nvidia หรือ LLVM บน CPU
สุดท้ายนี้ การขยายโมเดลและอัลกอริทึมการฝึกอบรมเพื่อรองรับขนาดเมทริกซ์ที่ใหญ่ขึ้นยังคงเป็นความท้าทายที่สำคัญ ปัจจุบัน OpenAlphaTensor รองรับขนาดเมทริกซ์สูงสุดที่ 5 แต่สามารถใช้ได้โดยแยกการคูณเมทริกซ์ที่ใหญ่กว่าออกเป็นกลุ่มของ MM ขนาดเล็กที่มีขนาดที่เล็กกว่า 5 วิธีนี้เป็นวิธีที่ต่ำกว่า และดำเนินการลดขนาดโดยตรงบนเทนเซอร์ขนาดใหญ่ที่สอดคล้องกับ MM เต็มสามารถนำไปสู่ผลลัพธ์ที่ดีกว่าในทางทฤษฎี
ดีเอโก้ ฟิออรี เป็น CTO ของ Nebuly AI ซึ่งเป็นบริษัทที่มุ่งมั่นที่จะทำให้การเพิ่มประสิทธิภาพ AI เป็นส่วนหนึ่งของชุดเครื่องมือของนักพัฒนาทุกคน
- เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
- เพลโตบล็อคเชน Web3 Metaverse ข่าวกรอง ขยายความรู้. เข้าถึงได้ที่นี่.
- ที่มา: https://www.kdnuggets.com/2023/03/first-open-source-implementation-deepmind-alphatensor.html?utm_source=rss&utm_medium=rss&utm_campaign=first-open-source-implementation-of-deepminds-alphatensor
- :เป็น
- ][หน้า
- $ ขึ้น
- 1
- 3d
- 8
- a
- สามารถ
- เกี่ยวกับเรา
- ข้างบน
- แน่นอน
- เร่ง
- ตาม
- ตาม
- ลงชื่อเข้าใช้
- ความถูกต้อง
- บรรลุ
- ประสบความสำเร็จ
- การกระทำ
- การปฏิบัติ
- จริง
- ที่เพิ่ม
- เพิ่มเติม
- ปรับ
- บุญธรรม
- ความก้าวหน้า
- ความได้เปรียบ
- หลังจาก
- ตัวแทน
- การรวมตัว
- ก้าวร้าว
- AI
- ระบบ AI
- จุดมุ่งหมาย
- ขั้นตอนวิธี
- อัลกอริทึม
- ทั้งหมด
- การอนุญาต
- ช่วยให้
- คนเดียว
- แล้ว
- ทางเลือก
- ในหมู่
- จำนวน
- วิเคราะห์
- และ
- อื่น
- ประยุกต์
- เข้าใกล้
- วิธีการ
- สถาปัตยกรรม
- เป็น
- บทความ
- เทียม
- ปัญญาประดิษฐ์
- AS
- ที่ได้รับมอบหมาย
- ที่เกี่ยวข้อง
- At
- อัตโนมัติ
- ใช้ได้
- หลีกเลี่ยง
- กลับ
- สำรอง
- ตาม
- เป็นพื้น
- รากฐาน
- BE
- เพราะ
- จะกลายเป็น
- ก่อน
- กำลัง
- ด้านล่าง
- มาตรฐาน
- ที่ดีที่สุด
- ดีกว่า
- ระหว่าง
- เกิน
- คณะกรรมการ
- เกมกระดาน
- ขอบเขต
- ที่กว้างขึ้น
- BT
- สร้าง
- สร้าง
- by
- ที่เรียกว่า
- CAN
- ไม่ได้
- กรณี
- ก่อให้เกิด
- ที่เกิดจาก
- บาง
- ท้าทาย
- ท้าทาย
- เปลี่ยนแปลง
- ช่อง
- ChatGPT
- เด็ก
- ทางเลือก
- เลือก
- เลือก
- อ้างถึง
- ชัดเจน
- อย่างเห็นได้ชัด
- รหัส
- เก็บรวบรวม
- รวมกัน
- มุ่งมั่น
- ร่วมกัน
- บริษัท
- เมื่อเทียบกับ
- การแข่งขัน
- ซับซ้อน
- ความซับซ้อน
- ส่วนประกอบ
- สงบ
- การประนีประนอม
- การคำนวณ
- พลังการคำนวณ
- คำนวณ
- การคำนวณ
- แนวความคิด
- แนวคิด
- สภาพ
- ความมั่นใจ
- พิจารณา
- ถือว่า
- พิจารณา
- พิจารณา
- การบริโภค
- มี
- ต่อ
- ตรงกันข้าม
- แปลง
- แกน
- ตรงกัน
- สอดคล้อง
- ได้
- ตอบโต้
- ซีพียู
- สร้าง
- การสร้าง
- เกณฑ์
- CTO
- ปัจจุบัน
- ขณะนี้
- ข้อมูล
- การซื้อขาย
- ตัดสินใจ
- ตัดสินใจ
- การตัดสินใจ
- การตัดสินใจ
- การตัดสินใจ
- ลึก
- การเรียนรู้ลึก ๆ
- Deepmind
- ขึ้นอยู่กับ
- อธิบาย
- กำหนด
- ผู้พัฒนา
- พัฒนาการ
- เครื่อง
- อุปกรณ์
- Dict
- ต่าง
- ความยากลำบาก
- Dimension
- มิติ
- โดยตรง
- ค้นพบ
- การค้นพบ
- กล่าวถึง
- การกระจาย
- แบ่งออก
- ลง
- หล่น
- ในระหว่าง
- e
- แต่ละ
- ก่อน
- อย่างง่ายดาย
- ขอบ
- มีประสิทธิภาพ
- ที่มีประสิทธิภาพ
- ทั้ง
- ธาตุ
- องค์ประกอบ
- ที่ฝัง
- สิ้นสุด
- ที่เพิ่มขึ้น
- มหาศาล
- พอ
- การเข้า
- ความผิดพลาด
- ประมาณการ
- ประมาณ
- อีเธอร์ (ETH)
- ประเมินค่า
- ประเมิน
- การประเมินการ
- การประเมินผล
- แม้
- ทุกๆ
- ตัวอย่าง
- ตัวอย่าง
- น่าตื่นเต้น
- การปฏิบัติ
- การขยายตัว
- ที่คาดหวัง
- ประสบการณ์
- อธิบาย
- อธิบาย
- การหาประโยชน์
- การสำรวจ
- สำรวจ
- สำรวจ
- สำรวจ
- แสดง
- ขยายออก
- การขยาย
- อย่างยิ่ง
- อย่างเป็นธรรม
- ครอบครัว
- เร็วขึ้น
- ข้อเสนอแนะ
- สองสาม
- รูป
- สุดท้าย
- หา
- ชื่อจริง
- ลอย
- โฟกัส
- ปฏิบัติตาม
- ดังต่อไปนี้
- รอยพระบาท
- สำหรับ
- ฟอร์ม
- รูป
- สูตร
- พบ
- ราคาเริ่มต้นที่
- เต็ม
- ฟังก์ชัน
- พื้นฐาน
- ต่อไป
- พัฒนาต่อไป
- อนาคต
- เกม
- เกม
- สร้าง
- สร้าง
- สร้าง
- การสร้าง
- ได้รับ
- ได้รับ
- ให้
- กำหนด
- ให้
- เป้าหมาย
- ไป
- ดี
- GPU
- GPUs
- กราฟ
- ยิ่งใหญ่
- บัญชีกลุ่ม
- กลุ่ม
- เติบโต
- การเจริญเติบโต
- ให้คำแนะนำ
- มือ
- การจัดการ
- ที่เกิดขึ้น
- ที่เกิดขึ้น
- ฮาร์ดแวร์
- อุปกรณ์ฮาร์ดแวร์
- อุปกรณ์ฮาร์ดแวร์
- มี
- มี
- โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติม
- ที่สูงที่สุด
- ขอบฟ้า
- สรุป ความน่าเชื่อถือของ Olymp Trade?
- ทำอย่างไร
- อย่างไรก็ตาม
- HTTPS
- ใหญ่
- เป็นมนุษย์
- i
- ฉันเป็น
- ในอุดมคติ
- IDX
- ภาพ
- ส่งผลกระทบ
- การดำเนินการ
- การดำเนินงาน
- สำคัญ
- ปรับปรุง
- การปรับปรุง
- in
- เพิ่ม
- เพิ่มขึ้น
- ขึ้น
- อิสระ
- ดัชนี
- ข้อมูล
- แรกเริ่ม
- อินพุต
- แทน
- คำแนะนำการใช้
- Intelligence
- น่าสนใจ
- ภายใน
- แนะนำ
- ปรีชา
- IT
- การย้ำ
- ITS
- ตัวเอง
- jpg
- KD นักเก็ต
- เก็บ
- คีย์
- ความรู้
- ที่รู้จักกัน
- ภาษา
- ใหญ่
- ที่มีขนาดใหญ่
- ชื่อสกุล
- ความแอบแฝง
- ล่าสุด
- ชั้น
- ชั้น
- นำ
- ได้เรียนรู้
- การเรียนรู้
- รายการ
- ดู
- ที่ต้องการหา
- Lot
- ทำ
- หลัก
- สำคัญ
- ทำ
- การทำ
- จัดการ
- การจัดการ
- หลาย
- แผนที่
- การทำแผนที่
- มดลูก
- เรื่อง
- สูงสุด
- ความหมาย
- มีความหมาย
- วิธี
- สมาชิก
- หน่วยความจำ
- วิธี
- วิธีการ
- เมตริก
- หายไป
- สารผสม
- แบบ
- โมเดล
- การแก้ไข
- โมดูล
- ข้อมูลเพิ่มเติม
- มีประสิทธิภาพมากขึ้น
- ยิ่งไปกว่านั้น
- มากที่สุด
- ย้าย
- ย้าย
- คูณ
- โดยธรรมชาติ
- ธรรมชาติ
- ใกล้
- จำเป็น
- จำเป็นต้อง
- จำเป็น
- เชิงลบ
- เครือข่าย
- ประสาท
- เครือข่ายประสาทเทียม
- ใหม่
- ถัดไป
- NLP
- ปม
- โหนด
- ไม่ใช่ผู้เชี่ยวชาญ
- ความคิด
- จำนวน
- Nvidia
- ที่ได้รับ
- of
- เสนอ
- on
- ONE
- เปิด
- โอเพนซอร์ส
- OpenAI
- การดำเนินการ
- การดำเนินการ
- ดีที่สุด
- การเพิ่มประสิทธิภาพ
- เพิ่มประสิทธิภาพ
- การปรับให้เหมาะสม
- Options
- เป็นต้นฉบับ
- อื่นๆ
- มิฉะนั้น
- เอาท์พุต
- ทั้งหมด
- กระดาษ
- เอกสาร
- พารามิเตอร์
- ส่วนหนึ่ง
- ในสิ่งที่สนใจ
- โดยเฉพาะ
- ส่วน
- รูปแบบไฟล์ PDF
- คน
- สมบูรณ์
- การปฏิบัติ
- ที่มีประสิทธิภาพ
- ระยะ
- ชิ้น
- เพลโต
- เพลโตดาต้าอินเทลลิเจนซ์
- เพลโตดาต้า
- เล่น
- ผู้เล่น
- เล่น
- จุด
- นโยบาย
- นโยบาย
- ตำแหน่ง
- เป็นไปได้
- ที่มีศักยภาพ
- อำนาจ
- ประยุกต์
- การปฏิบัติ
- คาดการณ์
- ที่คาดการณ์
- การตั้งค่า
- นำเสนอ
- ก่อน
- ความน่าจะเป็น
- อาจ
- ปัญหา
- กระบวนการ
- กระบวนการ
- ก่อ
- ผลิต
- ผลิตภัณฑ์
- ในอาชีพ
- โปรเกรสซีฟ
- แวว
- เสนอ
- พิสูจน์ได้
- ที่พิสูจน์แล้ว
- ประกาศ
- การตีพิมพ์
- แรม
- สุ่ม
- อันดับ
- ค่อนข้าง
- ถึง
- ต้นน้ำ
- เมื่อเร็ว ๆ นี้
- ลด
- ลดลง
- ลด
- กลั่น
- การเรียนรู้การเสริมแรง
- การเผยแพร่
- ที่เหลืออยู่
- ซากศพ
- โดดเด่น
- จำ
- รีโมท
- ซ้ำแล้วซ้ำอีก
- เป็นตัวแทนของ
- แสดงให้เห็นถึง
- จำเป็นต้องใช้
- ต้อง
- รับผิดชอบ
- หวงห้าม
- ผล
- ส่งผลให้
- ผลสอบ
- กลับ
- รับคืน
- ปฏิวัติ
- รางวัล
- แถว
- rt
- วิ่ง
- s
- เดียวกัน
- ลด
- ประหยัด
- สถานการณ์
- สถานการณ์
- โครงการ
- ค้นหา
- ที่สอง
- Section
- เมล็ดพันธุ์
- เลือก
- การเลือก
- การเลือก
- ตนเอง
- ชุด
- การตั้งค่า
- หลาย
- รูปร่าง
- ใช้งานร่วมกัน
- สั้น
- น่า
- โชว์
- แสดง
- แสดงให้เห็นว่า
- สัญญาณ
- สำคัญ
- อย่างมีความหมาย
- คล้ายคลึงกัน
- ความคล้ายคลึงกัน
- ง่าย
- ความง่าย
- ง่ายดาย
- จำลอง
- ตั้งแต่
- สถานการณ์
- ขนาด
- ขนาด
- เล็ก
- มีขนาดเล็กกว่า
- ภาพย่อ
- So
- ทางออก
- แก้
- การแก้
- บาง
- แหล่ง
- ช่องว่าง
- ช่องว่าง
- โดยเฉพาะ
- เฉพาะ
- ที่ระบุไว้
- ความเร็ว
- ใช้จ่าย
- การใช้จ่าย
- แยก
- สี่เหลี่ยม
- ซ้อนกัน
- ระยะ
- มาตรฐาน
- เริ่มต้น
- เริ่มต้น
- สถานะ
- รัฐของศิลปะ
- ระบุ
- สหรัฐอเมริกา
- สถิติ
- ขั้นตอน
- ขั้นตอน
- การหยุด
- จัดเก็บ
- เก็บไว้
- ร้านค้า
- ซื่อตรง
- ที่ประสบความสำเร็จ
- อย่างเช่น
- สนับสนุน
- รองรับ
- สังเคราะห์
- ข้อมูลสังเคราะห์
- สังเคราะห์
- ระบบ
- ระบบ
- ปรับปรุง
- เอา
- ใช้เวลา
- การ
- เป้า
- งาน
- งาน
- เทคนิค
- สถานีปลายทาง
- เงื่อนไขการใช้บริการ
- ที่
- พื้นที่
- ก้าวสู่อนาคต
- กราฟ
- ข้อมูล
- รัฐ
- ของพวกเขา
- พวกเขา
- ดังนั้น
- ดังนั้น
- ล้อยางขัดเหล่านี้ติดตั้งบนแกน XNUMX (มม.) ผลิตภัณฑ์นี้ถูกผลิตในหลายรูปทรง และหลากหลายเบอร์ความแน่นหนาของปริมาณอนุภาคขัดของมัน จะทำให้ท่านได้รับประสิทธิภาพสูงในการขัดและการใช้งานที่ยาวนาน
- ที่สาม
- สาม
- สามมิติ
- ตลอด
- เวลา
- ต้องใช้เวลามาก
- ไปยัง
- ร่วมกัน
- โทเค็น
- tokenization
- โทเค็น
- ราชสกุล
- เกินไป
- เครื่องมือ
- ด้านบน
- ไฟฉาย
- รวม
- แบบดั้งเดิม
- รถไฟ
- ผ่านการฝึกอบรม
- การฝึกอบรม
- รถไฟ
- เส้นโคจร
- เปลี่ยน
- รักษา
- จริง
- เข้าใจ
- จักรวาล
- ไม่ได้ใช้
- บันทึก
- ให้กับคุณ
- การปรับปรุง
- การปรับปรุง
- อัพเกรด
- us
- การใช้
- ใช้
- ผู้ใช้
- มักจะ
- ความคุ้มค่า
- ความคุ้มค่า
- ต่างๆ
- รุ่น
- วีดีโอ
- วิดีโอเกม
- เยี่ยมชมร้านค้า
- จำนวนการเข้าชม
- W
- ทาง..
- อะไร
- ที่
- ในขณะที่
- อย่างกว้างขวาง
- วิกิพีเดีย
- จะ
- การชนะ
- กับ
- คำ
- เวิร์กสเตชัน
- คุ้มค่า
- จะ
- การเขียน
- เขียน
- X
- ลมทะเล
- เป็นศูนย์