ความหมายของการดำเนินการ

ต่อไปนี้จะอธิบายความหมายของการดำเนินการที่กำหนดไว้ในอินเทอร์เฟซ XlaBuilder โดยปกติแล้ว การดำเนินการเหล่านี้จะแมปแบบหนึ่งต่อหนึ่งกับการดำเนินการที่กำหนดไว้ใน อินเทอร์เฟซ RPC ใน xla_data.proto

หมายเหตุเกี่ยวกับคำศัพท์: ประเภทข้อมูลทั่วไปที่ XLA จัดการคืออาร์เรย์ N มิติที่มีองค์ประกอบของประเภทที่สม่ำเสมอ (เช่น Float 32 บิต) ในเอกสารนี้ เราใช้ array เพื่อระบุอาร์เรย์ที่มีมิติข้อมูลโดยพลการ เพื่อความสะดวก กรณีพิเศษจะมีชื่อที่เฉพาะเจาะจงและคุ้นเคยมากขึ้น เช่น เวกเตอร์คืออาร์เรย์ 1 มิติ และเมทริกซ์คืออาร์เรย์ 2 มิติ

ดูข้อมูลเพิ่มเติมเกี่ยวกับโครงสร้างของ Op ในรูปร่างและเลย์เอาต์และ เลย์เอาต์แบบเรียงต่อกัน

หน้าท้อง

ดูเพิ่มเติม XlaBuilder::Abs

ค่าสัมบูรณ์แบบองค์ประกอบ x -> |x|

Abs(operand)

ดูข้อมูล StableHLO ได้ที่ StableHLO - abs

เพิ่ม

ดูเพิ่มเติม XlaBuilder::Add

ดำเนินการบวกแบบทีละองค์ประกอบของ lhs และ rhs

Add(lhs, rhs)

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

มีตัวแปรอื่นที่รองรับการออกอากาศแบบหลายมิติ สำหรับ Add ดังนี้

Add(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - add

AddDependency

ดูเพิ่มเติม HloInstruction::AddDependency

AddDependency อาจปรากฏในข้อมูลการทิ้ง HLO แต่ไม่ได้มีไว้ให้ผู้ใช้ปลายทางสร้างขึ้นด้วยตนเอง

AfterAll

ดูเพิ่มเติม XlaBuilder::AfterAll

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

AfterAll(tokens)

ดูข้อมูล StableHLO ได้ที่ StableHLO - after_all

AllGather

ดูเพิ่มเติม XlaBuilder::AllGather

ดำเนินการต่อกันในสำเนา

AllGather(operand, all_gather_dimension, shard_count, replica_groups, channel_id, layout, use_global_device_ids)

• replica_groups คือรายการกลุ่มรีพลิคาระหว่างที่ทำการต่อกัน (ดึงรหัสรีพลิคาสำหรับรีพลิคาปัจจุบันได้โดยใช้ ReplicaId) ลำดับของรีพลิคาในแต่ละกลุ่มจะกำหนด ลำดับที่อินพุตของรีพลิคาอยู่ในผลลัพธ์ replica_groups ต้องว่างเปล่า (ในกรณีนี้ ตัวจำลองทั้งหมดจะอยู่ในกลุ่มเดียว เรียงจาก 0 ถึง N - 1) หรือมีจำนวนองค์ประกอบเท่ากับ จำนวนตัวจำลอง เช่น replica_groups = {0, 2}, {1, 3} จะทำการ เชื่อมต่อระหว่างรีพลิกากับ 0 และ 2 รวมถึง 1 และ 3
• shard_count คือขนาดของกลุ่มรีพลิกาทุกกลุ่ม เราต้องการข้อมูลนี้ในกรณีที่replica_groupsว่างเปล่า
• channel_id ใช้สำหรับการสื่อสารข้ามโมดูล โดยมีเพียงall-gather การดำเนินการที่มีchannel_id เดียวกันเท่านั้นที่สื่อสารกันได้
• use_global_device_ids แสดงผลเป็นจริงหากรหัสในการกำหนดค่า ReplicaGroup แสดงรหัสส่วนกลางของ (replica_id * partition_count + partition_id) แทนรหัสจำลอง ซึ่งช่วยให้จัดกลุ่มอุปกรณ์ได้ยืดหยุ่นมากขึ้นหาก การลดทั้งหมดนี้เป็นทั้งแบบข้ามพาร์ติชันและข้ามรีพลิกา

รูปร่างเอาต์พุตคือรูปร่างอินพุตที่มีขนาดใหญ่ขึ้น all_gather_dimensionshard_count เท่า เช่น หากมีรีพลิกา 2 รายการและตัวถูกดำเนินการมีค่า [1.0, 2.5] และ [3.0, 5.25] ตามลำดับในรีพลิกาทั้ง 2 รายการ ค่าเอาต์พุตจาก Op นี้ที่ all_gather_dim เป็น 0 จะเป็น [1.0, 2.5, 3.0,5.25] ในรีพลิกาทั้ง 2 รายการ

API ของ AllGather จะแยกออกเป็นคำสั่ง HLO 2 รายการภายใน (AllGatherStart และ AllGatherDone)

ดูเพิ่มเติม HloInstruction::CreateAllGatherStart

AllGatherStart, AllGatherDone ทำหน้าที่เป็นองค์ประกอบพื้นฐานใน HLO การดำเนินการเหล่านี้อาจ ปรากฏในข้อมูลการทิ้ง HLO แต่ไม่ได้มีไว้ให้ผู้ใช้ สร้างด้วยตนเอง

ดูข้อมูล StableHLO ได้ที่ StableHLO - all_gather

AllReduce

ดูเพิ่มเติม XlaBuilder::AllReduce

ทำการคำนวณที่กำหนดเองในรีพลิกาทั้งหมด

AllReduce(operand, computation, replica_groups, channel_id, shape_with_layout, use_global_device_ids)

• เมื่อ operand เป็นทูเพิลของอาร์เรย์ ระบบจะดำเนินการ all-reduce กับแต่ละ องค์ประกอบของทูเพิล
• replica_groups คือรายการกลุ่มรีพลิคาที่จะทำการลดค่า (สามารถดึงข้อมูลรหัสรีพลิคาสำหรับรีพลิคาปัจจุบันได้โดยใช้ ReplicaId) replica_groups ต้องว่างเปล่า (ในกรณีที่รีพลิคาทั้งหมดอยู่ในกลุ่มเดียว) หรือมีจำนวนองค์ประกอบเท่ากับจำนวนรีพลิคา เช่น replica_groups = {0, 2}, {1, 3} จะทำการลดระหว่างสำเนา 0 กับ 2 และ 1 กับ 3
• channel_id ใช้สำหรับการสื่อสารข้ามโมดูล โดยมีเพียงall-reduce การดำเนินการที่มีchannel_id เดียวกันเท่านั้นที่สื่อสารกันได้
• shape_with_layout: บังคับให้เลย์เอาต์ของ AllReduce เป็นเลย์เอาต์ที่กำหนด ใช้เพื่อรับประกันเลย์เอาต์เดียวกันสำหรับกลุ่มการดำเนินการ AllReduce ที่คอมไพล์แยกกัน
• use_global_device_ids แสดงผลเป็นจริงหากรหัสในการกำหนดค่า ReplicaGroup แสดงรหัสส่วนกลางของ (replica_id * partition_count + partition_id) แทนรหัสจำลอง ซึ่งช่วยให้จัดกลุ่มอุปกรณ์ได้ยืดหยุ่นมากขึ้นหาก การลดทั้งหมดนี้เป็นทั้งแบบข้ามพาร์ติชันและข้ามรีพลิกา

รูปร่างเอาต์พุตจะเหมือนกับรูปร่างอินพุต ตัวอย่างเช่น หากมีรีพลิกา 2 รายการและตัวถูกดำเนินการมีค่า [1.0, 2.5] และ [3.0, 5.25] ตามลำดับในรีพลิกาทั้ง 2 รายการ ค่าเอาต์พุตจาก Op นี้และการคำนวณ การบวกจะเป็น [4.0, 7.75] ในรีพลิกาทั้ง 2 รายการ หากอินพุตเป็น ทูเพิล เอาต์พุตก็จะเป็นทูเพิลเช่นกัน

การคำนวณผลลัพธ์ของ AllReduce ต้องมีอินพุต 1 รายการจากแต่ละรีพลิก ดังนั้นหากรีพลิกหนึ่งเรียกใช้โหนด AllReduce มากกว่ารีพลิกอื่น รีพลิกแรกจะรอไปเรื่อยๆ เนื่องจากรีพลิกาทั้งหมดเรียกใช้โปรแกรมเดียวกัน จึงมีวิธีไม่มากนักที่จะทำให้เกิดเหตุการณ์ดังกล่าว แต่ก็เป็นไปได้เมื่อเงื่อนไขของลูป while ขึ้นอยู่กับข้อมูลจาก infeed และข้อมูลที่ infeed ทำให้ลูป while วนซ้ำหลายครั้งในรีพลิกาหนึ่งมากกว่าอีกรีพลิกาหนึ่ง

API ของ AllReduce จะแยกออกเป็นคำสั่ง HLO 2 รายการภายใน (AllReduceStart และ AllReduceDone)

ดูเพิ่มเติม HloInstruction::CreateAllReduceStart

AllReduceStart และ AllReduceDone ทำหน้าที่เป็นองค์ประกอบพื้นฐานใน HLO การดำเนินการเหล่านี้อาจ ปรากฏในข้อมูลการทิ้ง HLO แต่ไม่ได้มีไว้ให้ผู้ใช้ สร้างด้วยตนเอง

CrossReplicaSum

ดูเพิ่มเติม XlaBuilder::CrossReplicaSum

ดำเนินการ AllReduce ด้วยการคำนวณผลรวม

CrossReplicaSum(operand, replica_groups)

แสดงผลผลรวมของค่าตัวถูกดำเนินการภายในแต่ละกลุ่มย่อยของสำเนา สำเนาทั้งหมดจะป้อนข้อมูล 1 รายการไปยังผลรวม และสำเนาทั้งหมดจะได้รับผลรวมที่ได้ สำหรับแต่ละกลุ่มย่อย

AllToAll

ดูเพิ่มเติม XlaBuilder::AllToAll

AllToAll เป็นการดำเนินการแบบกลุ่มที่ส่งข้อมูลจากทุกแกนไปยังทุกแกน โดยมี 2 ระยะ ดังนี้

1. ระยะกระจาย ในแต่ละคอร์ ระบบจะแบ่งตัวถูกดำเนินการออกเป็นsplit_count จำนวนบล็อกตามsplit_dimensions และกระจายบล็อก ไปยังทุกคอร์ เช่น ระบบจะส่งบล็อกที่ i ไปยังคอร์ที่ i
2. ระยะรวบรวม แต่ละคอร์จะต่อบล็อกที่ได้รับตามconcat_dimension

คุณกำหนดค่าแกนที่เข้าร่วมได้โดยทำดังนี้

• replica_groups: ReplicaGroup แต่ละกลุ่มจะมีรายการรหัสของรีพลิก้า ที่เข้าร่วมในการคำนวณ (ดึงรหัสของรีพลิก้าปัจจุบันได้โดยใช้ ReplicaId) AllToAll จะใช้ ภายในกลุ่มย่อยตามลำดับที่ระบุ เช่น replica_groups = { {1,2,3}, {4,5,0} } หมายความว่าจะใช้ AllToAll ภายในสำเนา {1, 2, 3} และในเฟสการรวบรวม และบล็อกที่ได้รับจะต่อกันตามลำดับเดียวกันคือ 1, 2, 3 จากนั้นจะใช้ AllToAll อีกรายการภายในรีพลิกา 4, 5, 0 และลำดับการต่อกันคือ 4, 5, 0 หาก replica_groups ว่างเปล่า สำเนาทั้งหมดจะอยู่ในกลุ่มเดียวตามลำดับการต่อกันของลักษณะที่ปรากฏ

สิ่งที่ต้องมีก่อน

• ขนาดมิติข้อมูลของตัวถูกดำเนินการใน split_dimension หารด้วย split_count ได้ลงตัว
• รูปร่างของตัวถูกดำเนินการไม่ใช่ Tuple

AllToAll(operand, split_dimension, concat_dimension, split_count, replica_groups, layout, channel_id)

ดูข้อมูลเพิ่มเติมเกี่ยวกับรูปร่างและเลย์เอาต์ได้ที่ xla::shapes

ดูข้อมูล StableHLO ได้ที่ StableHLO - all_to_all

AllToAll - ตัวอย่างที่ 1

XlaBuilder b("alltoall");
auto x = Parameter(&b, 0, ShapeUtil::MakeShape(F32, {4, 16}), "x");
AllToAll(
    x,
    /*split_dimension=*/ 1,
    /*concat_dimension=*/ 0,
    /*split_count=*/ 4);

ในตัวอย่างด้านบน มี 4 คอร์ที่เข้าร่วมใน Alltoall ในแต่ละ คอร์ ระบบจะแบ่งตัวถูกดำเนินการออกเป็น 4 ส่วนตามมิติข้อมูลที่ 1 ดังนั้นแต่ละส่วนจะมี รูปร่าง f32[4,4] โดยจะกระจาย 4 ส่วนไปยังคอร์ทั้งหมด จากนั้นแต่ละแกนจะ ต่อชิ้นส่วนที่ได้รับตามมิติข้อมูล 0 ตามลำดับแกน 0-4 ดังนั้น เอาต์พุตในแต่ละแกนจึงมีรูปร่างเป็น f32[16,4]

AllToAll - ตัวอย่างที่ 2 - StableHLO

ในตัวอย่างด้านบน มีรีพลิกา 2 รายการที่เข้าร่วมใน AllToAll ใน แต่ละสำเนา ตัวถูกดำเนินการมีรูปร่าง f32[2,4] ตัวถูกดำเนินการจะแบ่งออกเป็น 2 ส่วน ตามมิติข้อมูลที่ 1 ดังนั้นแต่ละส่วนจะมีรูปร่าง f32[2,2] จากนั้นจะมีการแลกเปลี่ยน 2 ส่วนนี้ ในสำเนาตามตำแหน่งในกลุ่มสำเนา แต่ละรีพลิกาจะรวบรวมส่วนที่เกี่ยวข้องจากทั้งตัวถูกดำเนินการและต่อกัน ตามมิติที่ 0 ดังนั้น เอาต์พุตในแต่ละรีพลิกะจะมีรูปร่าง f32[4,2]

RaggedAllToAll

ดูเพิ่มเติม XlaBuilder::RaggedAllToAll

RaggedAllToAll ดำเนินการแบบกลุ่มแบบทั้งหมดต่อทั้งหมด โดยที่อินพุตและเอาต์พุตเป็นเทนเซอร์แบบไม่สม่ำเสมอ

RaggedAllToAll(input, input_offsets, send_sizes, output, output_offsets, recv_sizes, replica_groups, channel_id)

เทนเซอร์แบบไม่สม่ำเสมอจะกำหนดโดยชุดเทนเซอร์ 3 รายการ ได้แก่

• data: dataเทนเซอร์ "ไม่สม่ำเสมอ" ตามมิติข้อมูลด้านนอกสุด ซึ่งแต่ละองค์ประกอบที่จัดทำดัชนีจะมีขนาดแตกต่างกัน
• offsets': เทนเซอร์ offsets จะจัดทำดัชนีมิติข้อมูลด้านนอกสุดของเทนเซอร์ data และแสดงออฟเซ็ตเริ่มต้นของแต่ละองค์ประกอบที่ไม่สม่ำเสมอของ เทนเซอร์ data
• sizes: เทนเซอร์ sizes แสดงขนาดขององค์ประกอบที่ไม่สม่ำเสมอแต่ละรายการของ เทนเซอร์ data โดยขนาดจะระบุในหน่วยขององค์ประกอบย่อย องค์ประกอบย่อยกำหนดเป็นคำต่อท้ายของรูปร่างเทนเซอร์ "data" ที่ได้จากการ นำมิติข้อมูล "ไม่สม่ำเสมอ" ที่อยู่นอกสุดออก
• เทนเซอร์ offsets และ sizes ต้องมีขนาดเท่ากัน

ตัวอย่างเทนเซอร์แบบไม่สม่ำเสมอ

data: [8,3] =
{ {a,b,c},{d,e,f},{g,h,i},{j,k,l},{m,n,o},{p,q,r},{s,t,u},{v,w,x} }

offsets: [3] = {0, 1, 4}

sizes: [3] = {1, 3, 4}

// Index 'data' at 'offsets'[0], 'sizes'[0]' // {a,b,c}

// Index 'data' at 'offsets'[1], 'sizes'[1]' // {d,e,f},{g,h,i},{j,k,l}

// Index 'data' at 'offsets'[2], 'sizes'[2]' // {m,n,o},{p,q,r},{s,t,u},{v,w,x}

output_offsets ต้องได้รับการแบ่งส่วนในลักษณะที่แต่ละรีพลิเคชันมีออฟเซ็ตใน มุมมองเอาต์พุตรีพลิเคชันเป้าหมาย

สำหรับออฟเซ็ตเอาต์พุตที่ i เครื่องจำลองปัจจุบันจะส่ง input[input_offsets[i]:input_offsets[i]+input_sizes[i]] อัปเดตไปยังเครื่องจำลองที่ i ซึ่งจะเขียนไปยัง output_i[output_offsets[i]:output_offsets[i]+send_sizes[i]] ในเครื่องจำลองที่ i output

เช่น หากเรามีรีพลิกา 2 รายการ

replica 0:
input: [1, 2, 2]
output:[0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 2]
output_offsets: [0, 0]
recv_sizes: [1, 1]

replica 1:
input: [3, 4, 0]
output: [0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 1]
output_offsets: [1, 2]
recv_sizes: [2, 1]

// replica 0's result will be: [1, 3, 0, 0]
// replica 1's result will be: [2, 2, 4, 0]

HLO แบบ All-to-all ที่ไม่สม่ำเสมอกันมีอาร์กิวเมนต์ต่อไปนี้

• input: เทนเซอร์ข้อมูลอินพุตแบบไม่สม่ำเสมอ
• output: เทนเซอร์ข้อมูลเอาต์พุตแบบไม่สม่ำเสมอ
• input_offsets: เทนเซอร์ออฟเซ็ตอินพุตแบบไม่สม่ำเสมอ
• send_sizes: เทนเซอร์ขนาดการส่งแบบไม่สม่ำเสมอ
• output_offsets: อาร์เรย์ของออฟเซ็ตแบบไม่สม่ำเสมอในเอาต์พุตของรีพลิกาเป้าหมาย
• recv_sizes: เทนเซอร์ขนาด recv ที่ไม่สม่ำเสมอ

เทนเซอร์ *_offsets และ *_sizes ทั้งหมดต้องมีรูปร่างเดียวกัน

รองรับ 2 รูปร่างสำหรับเทนเซอร์ *_offsets และ *_sizes ดังนี้

• [num_devices] ซึ่งการส่งแบบไม่สม่ำเสมออาจส่งการอัปเดตไปยังอุปกรณ์ระยะไกลแต่ละเครื่องในกลุ่มรีเพล็กซ์ได้สูงสุด 1 รายการ เช่น

for (remote_device_id : replica_group) {
     SEND input[input_offsets[remote_device_id]],
     output[output_offsets[remote_device_id]],
     send_sizes[remote_device_id] }

• [num_devices, num_updates] ซึ่งการกระจายข้อมูลแบบไม่สม่ำเสมออาจส่งการอัปเดตได้สูงสุด num_updates ไปยังอุปกรณ์ระยะไกลเดียวกัน (แต่ละรายการมีออฟเซ็ตต่างกัน) สำหรับอุปกรณ์ระยะไกลแต่ละเครื่องในกลุ่มรีเพล็ก

เช่น

for (remote_device_id : replica_group) {
    for (update_idx : num_updates) {
        SEND input[input_offsets[remote_device_id][update_idx]],
        output[output_offsets[remote_device_id][update_idx]]],
        send_sizes[remote_device_id][update_idx] } }

และ

ดูเพิ่มเติม XlaBuilder::And

ดำเนินการ AND แบบทีละองค์ประกอบของเทนเซอร์ 2 ตัว ได้แก่ lhs และ rhs

And(lhs, rhs)

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

มีตัวแปรอื่นที่รองรับการออกอากาศแบบหลายมิติ สำหรับ

And(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - and

Async

ดู HloInstruction::CreateAsyncStart HloInstruction::CreateAsyncUpdate HloInstruction::CreateAsyncDone ด้วย

AsyncDone, AsyncStart และ AsyncUpdate เป็นคำสั่ง HLO ภายในที่ใช้ สำหรับการดำเนินการแบบไม่พร้อมกันและทำหน้าที่เป็นองค์ประกอบพื้นฐานใน HLO การดำเนินการเหล่านี้อาจปรากฏในข้อมูลที่ดัมพ์ของ HLO แต่ไม่ได้มีไว้ให้ผู้ใช้ปลายทางสร้างขึ้นด้วยตนเอง

Atan2

ดูเพิ่มเติม XlaBuilder::Atan2

ดำเนินการ atan2 แบบทีละองค์ประกอบใน lhs และ rhs

Atan2(lhs, rhs)

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

Atan2 มีตัวแปรทางเลือกที่รองรับการออกอากาศแบบหลายมิติ ดังนี้

Atan2(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - atan2

BatchNormGrad

ดูคำอธิบายโดยละเอียดของอัลกอริทึมได้ที่ XlaBuilder::BatchNormGrad และเอกสารต้นฉบับเกี่ยวกับการปรับมาตรฐานแบบกลุ่ม

คำนวณการไล่ระดับของ Batch Norm

BatchNormGrad(operand, scale, batch_mean, batch_var, grad_output, epsilon, feature_index)

สำหรับฟีเจอร์แต่ละรายการในมิติข้อมูลฟีเจอร์ (feature_index คือดัชนีสำหรับ มิติข้อมูลฟีเจอร์ใน operand) การดำเนินการจะคำนวณการไล่ระดับสีโดยอิงตาม operand, offset และ scale ในมิติข้อมูลอื่นๆ ทั้งหมด feature_index ต้องเป็นดัชนีที่ถูกต้องสำหรับมิติข้อมูลฟีเจอร์ใน operand

การไล่ระดับสีทั้ง 3 แบบกำหนดโดยสูตรต่อไปนี้ (สมมติว่าอาร์เรย์ 4 มิติเป็น operand และมีดัชนีมิติข้อมูลฟีเจอร์ l, ขนาดกลุ่ม m และขนาดเชิงพื้นที่ w และ h)

\[ \begin{split} c_l&= \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \left( \nabla y_{ijkl} \frac{x_{ijkl} - \mu_l}{\sigma^2_l+\epsilon} \right) \\\\ d_l&= \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \\\\ \nabla x_{ijkl} &= \frac{\gamma_{l} }{\sqrt{\sigma^2_{l}+\epsilon} } \left( \nabla y_{ijkl} - d_l - c_l (x_{ijkl} - \mu_{l}) \right) \\\\ \nabla \gamma_l &= \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \left( \nabla y_{ijkl} \frac{x_{ijkl} - \mu_l}{\sqrt{\sigma^2_{l}+\epsilon} } \right) \\\\\ \nabla \beta_l &= \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \end{split} \]

อินพุต batch_mean และ batch_var แสดงค่าโมเมนต์ในมิติข้อมูลกลุ่ม และมิติข้อมูลเชิงพื้นที่

ประเภทเอาต์พุตคือ Tuple ของแฮนเดิล 3 รายการ ดังนี้

ดูข้อมูล StableHLO ได้ที่ StableHLO - batch_norm_grad

BatchNormInference

ดูคำอธิบายโดยละเอียดของอัลกอริทึมได้ที่ XlaBuilder::BatchNormInference และเอกสารต้นฉบับเกี่ยวกับการปรับมาตรฐานแบบกลุ่ม

ทำให้อาร์เรย์เป็นมาตรฐานในมิติข้อมูลแบบกลุ่มและเชิงพื้นที่

BatchNormInference(operand, scale, offset, mean, variance, epsilon, feature_index)

สําหรับแต่ละฟีเจอร์ในมิติข้อมูลฟีเจอร์ (feature_index คือดัชนีของ มิติข้อมูลฟีเจอร์ใน operand) การดําเนินการจะคํานวณค่าเฉลี่ยและความแปรปรวน ในมิติข้อมูลอื่นๆ ทั้งหมด และใช้ค่าเฉลี่ยและความแปรปรวนเพื่อทําให้แต่ละ องค์ประกอบใน operand เป็นปกติ feature_index ต้องเป็นดัชนีที่ถูกต้องสำหรับมิติข้อมูลฟีเจอร์ใน operand

BatchNormInference เทียบเท่ากับการเรียกใช้ BatchNormTraining โดยไม่ต้อง คำนวณ mean และ variance สำหรับแต่ละกลุ่ม โดยจะใช้ข้อมูลนำเข้า mean และ variance แทนเป็นค่าประมาณ วัตถุประสงค์ของ Op นี้คือการลดเวลาในการตอบสนองในการอนุมาน จึงได้ชื่อว่า BatchNormInference

เอาต์พุตคืออาร์เรย์แบบ n มิติที่ได้รับการทำให้เป็นมาตรฐานซึ่งมีรูปร่างเหมือนกับอินพุต operand

ดูข้อมูล StableHLO ได้ที่ StableHLO - batch_norm_inference

BatchNormTraining

ดูเพิ่มเติม XlaBuilder::BatchNormTraining และthe original batch normalization paper เพื่อดูคำอธิบายโดยละเอียดของอัลกอริทึม

ทำให้อาร์เรย์เป็นมาตรฐานในมิติข้อมูลแบบกลุ่มและเชิงพื้นที่

BatchNormTraining(operand, scale, offset, epsilon, feature_index)

สําหรับแต่ละฟีเจอร์ในมิติข้อมูลฟีเจอร์ (feature_index คือดัชนีของ มิติข้อมูลฟีเจอร์ใน operand) การดําเนินการจะคํานวณค่าเฉลี่ยและความแปรปรวน ในมิติข้อมูลอื่นๆ ทั้งหมด และใช้ค่าเฉลี่ยและความแปรปรวนเพื่อทําให้แต่ละ องค์ประกอบใน operand เป็นปกติ feature_index ต้องเป็นดัชนีที่ถูกต้องสำหรับมิติข้อมูลฟีเจอร์ใน operand

อัลกอริทึมมีดังนี้สำหรับแต่ละกลุ่มใน operand \(x\) ที่มีองค์ประกอบ m ที่มี w และ h เป็นขนาดของมิติเชิงพื้นที่ (สมมติว่า operand เป็นอาร์เรย์ 4 มิติ)

• คำนวณค่าเฉลี่ยของกลุ่ม \(\mu_l\) สำหรับแต่ละฟีเจอร์ l ในมิติข้อมูลฟีเจอร์ \(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\)

• คำนวณความแปรปรวนของกลุ่ม \(\sigma^2_l\): $\sigma^2l=\frac{1}{mwh}\sum{i=1}^m\sum{j=1}^w\sum{k=1}^h (x_{ijkl} - \mu_l)^2$

• ปรับให้เป็นมาตรฐาน ปรับขนาด และเลื่อน: \(y_{ijkl}=\frac{\gamma_l(x_{ijkl}-\mu_l)}{\sqrt[2]{\sigma^2_l+\epsilon} }+\beta_l\)

ระบบจะเพิ่มค่าเอปซิลอน ซึ่งมักจะเป็นจำนวนน้อย เพื่อหลีกเลี่ยงข้อผิดพลาดในการหารด้วย 0

ประเภทเอาต์พุตคือ Tuple ของ XlaOp 3 รายการ

batch_mean และ batch_var คือโมเมนต์ที่คํานวณในมิติข้อมูลกลุ่มและมิติข้อมูลเชิงพื้นที่โดยใช้สูตรด้านบน

ดูข้อมูล StableHLO ได้ที่ StableHLO - batch_norm_training

Bitcast

ดูเพิ่มเติม HloInstruction::CreateBitcast

Bitcast อาจปรากฏในข้อมูลการทิ้ง HLO แต่ไม่ได้มีไว้ให้ผู้ใช้ปลายทางสร้างขึ้นด้วยตนเอง

BitcastConvertType

ดูเพิ่มเติม XlaBuilder::BitcastConvertType

คล้ายกับ tf.bitcast ใน TensorFlow ซึ่งดำเนินการบิตแคสต์ระดับองค์ประกอบ จากรูปร่างข้อมูลไปยังรูปร่างเป้าหมาย ขนาดอินพุตและเอาต์พุตต้องตรงกัน เช่น องค์ประกอบ s32 จะกลายเป็นองค์ประกอบ f32 ผ่านรูทีนบิตแคสต์ และองค์ประกอบ s32 หนึ่งรายการจะกลายเป็นองค์ประกอบ s8 สี่รายการ Bitcast ได้รับการติดตั้งใช้งานเป็นการแคสต์ระดับต่ำ ดังนั้นเครื่องที่มีการแทนค่าจุดลอยต่างกันจะให้ผลลัพธ์ที่แตกต่างกัน

BitcastConvertType(operand, new_element_type)

มิติข้อมูลของตัวถูกดำเนินการและรูปร่างเป้าหมายต้องตรงกัน ยกเว้น มิติข้อมูลสุดท้ายซึ่งจะเปลี่ยนตามอัตราส่วนของขนาดดั้งเดิมก่อนและ หลังการแปลง

ประเภทองค์ประกอบต้นทางและปลายทางต้องไม่ใช่ Tuple

ดูข้อมูล StableHLO ได้ที่ StableHLO - bitcast_convert

Bitcast-converting to primitive type of different width

BitcastConvert คำสั่ง HLO รองรับกรณีที่ขนาดของประเภทองค์ประกอบเอาต์พุต T' ไม่เท่ากับขนาดขององค์ประกอบอินพุต T เนื่องจากการดำเนินการทั้งหมดเป็นแนวคิดการบิตแคสต์และไม่ได้เปลี่ยนไบต์พื้นฐาน รูปร่างขององค์ประกอบเอาต์พุตจึงต้องเปลี่ยน สำหรับ B = sizeof(T), B' = sizeof(T') มี 2 กรณีที่อาจเกิดขึ้น

ก่อนอื่น เมื่อ B > B' รูปร่างเอาต์พุตจะมีมิติข้อมูลใหม่ที่เล็กที่สุดซึ่งมีขนาดเป็น B/B' เช่น

  f16[10,2]{1,0} %output = f16[10,2]{1,0} bitcast-convert(f32[10]{0} %input)

กฎสำหรับสเกลาร์ที่มีผลจะยังคงเหมือนเดิม

  f16[2]{0} %output = f16[2]{0} bitcast-convert(f32[] %input)

หรือสำหรับ B' > B คำสั่งกำหนดให้มิติข้อมูลเชิงตรรกะสุดท้าย ของรูปร่างอินพุตต้องเท่ากับ B'/B และระบบจะทิ้งมิติข้อมูลนี้ระหว่าง การแปลง

  f32[10]{0} %output = f32[10]{0} bitcast-convert(f16[10,2]{1,0} %input)

โปรดทราบว่า Conversion ระหว่างบิตความกว้างที่แตกต่างกันไม่ใช่แบบทีละองค์ประกอบ

ประกาศ

ดูเพิ่มเติม XlaBuilder::Broadcast

เพิ่มมิติข้อมูลลงในอาร์เรย์โดยการทำซ้ำข้อมูลในอาร์เรย์

Broadcast(operand, broadcast_sizes)

ระบบจะแทรกมิติข้อมูลใหม่ทางด้านซ้าย กล่าวคือ หาก broadcast_sizes มีค่า {a0, ..., aN} และรูปร่างตัวถูกดำเนินการมีมิติข้อมูล {b0, ..., bM} รูปร่างของเอาต์พุตจะมีมิติข้อมูล {a0, ..., aN, b0, ..., bM}

ดัชนีมิติข้อมูลใหม่จะอยู่ในสำเนาของตัวถูกดำเนินการ กล่าวคือ

output[i0, ..., iN, j0, ..., jM] = operand[j0, ..., jM]

เช่น หาก operand เป็นสเกลาร์ f32 ที่มีค่า 2.0f และ broadcast_sizes เป็น {2, 3} ผลลัพธ์จะเป็นอาร์เรย์ที่มีรูปร่าง f32[2, 3] และค่าทั้งหมดในผลลัพธ์จะเป็น 2.0f

ดูข้อมูล StableHLO ได้ที่ StableHLO - broadcast

BroadcastInDim

ดูเพิ่มเติม XlaBuilder::BroadcastInDim

ขยายขนาดและจำนวนมิติข้อมูลของอาร์เรย์โดยการทำซ้ำข้อมูล ในอาร์เรย์

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

คล้ายกับการออกอากาศ แต่ช่วยให้เพิ่มมิติข้อมูลได้ทุกที่และขยาย มิติข้อมูลที่มีอยู่ด้วยขนาด 1

ระบบจะออกอากาศ operand ไปยังรูปร่างที่อธิบายโดย out_dim_size broadcast_dimensions จะแมปมิติข้อมูลของ operand กับมิติข้อมูลของ รูปร่างเป้าหมาย กล่าวคือ มิติข้อมูลที่ i ของตัวถูกดำเนินการจะแมปกับมิติข้อมูลที่ broadcast_dimension[i] ของรูปร่างเอาต์พุต มิติข้อมูลของ operand ต้องมีขนาด 1 หรือมีขนาดเท่ากับมิติข้อมูลในเอาต์พุต รูปร่างที่แมป ส่วนมิติข้อมูลที่เหลือจะเติมด้วยมิติข้อมูลที่มี ขนาด 1 จากนั้นการออกอากาศที่มีมิติที่ลดทอนจะออกอากาศตามมิติที่ลดทอนเหล่านี้ เพื่อให้ได้รูปร่างเอาต์พุต ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

โทร

ดูเพิ่มเติม XlaBuilder::Call

เรียกใช้การคำนวณด้วยอาร์กิวเมนต์ที่ระบุ

Call(computation, operands...)

Arity และประเภทของ operands ต้องตรงกับพารามิเตอร์ของ computation คุณไม่จำเป็นต้องมี operands

CompositeCall

ดูเพิ่มเติม XlaBuilder::CompositeCall

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

ฟิลด์เวอร์ชัน (ค่าเริ่มต้นคือ 0) ใช้เพื่อระบุเมื่อมีการเปลี่ยนแปลงความหมายของคอมโพสิต

การดำเนินการนี้จะใช้เป็น kCall ที่มีแอตทริบิวต์ is_composite=true ฟิลด์ decomposition จะระบุโดยแอตทริบิวต์ computation แอตทริบิวต์ส่วนหน้า จะจัดเก็บแอตทริบิวต์ที่เหลือซึ่งมีคำนำหน้าเป็น composite.

ตัวอย่างการดำเนินการ CompositeCall

f32[] call(f32[] %cst), to_apply=%computation, is_composite=true,
frontend_attributes = {
  composite.name="foo.bar",
  composite.attributes={n = 1 : i32, tensor = dense<1> : tensor<i32>},
  composite.version="1"
}

CompositeCall(computation, operands..., name, attributes, version)

decomposition ของการดำเนินการไม่ใช่ฟิลด์ที่เรียกว่า แต่จะปรากฏเป็นแอตทริบิวต์ to_apply ซึ่งชี้ไปยังฟังก์ชันที่มีการใช้งานระดับล่างกว่า นั่นคือ to_apply=%funcname

ดูข้อมูลเพิ่มเติมเกี่ยวกับการรวมและการแยกย่อยได้ที่ข้อกำหนด StableHLO

Cbrt

ดูเพิ่มเติม XlaBuilder::Cbrt

การดำเนินการรากที่สามแบบทีละองค์ประกอบ x -> cbrt(x)

Cbrt(operand)

นอกจากนี้ Cbrt ยังรองรับอาร์กิวเมนต์ result_accuracy ที่ไม่บังคับด้วย

Cbrt(operand, result_accuracy)

ดูข้อมูลเพิ่มเติมเกี่ยวกับ result_accuracy ได้ที่ ความถูกต้องของผลลัพธ์

ดูข้อมูล StableHLO ได้ที่ StableHLO - cbrt

เพดาน

ดูเพิ่มเติม XlaBuilder::Ceil

ฟังก์ชันเพดานแบบองค์ประกอบต่อองค์ประกอบ x -> ⌈x⌉

Ceil(operand)

ดูข้อมูล StableHLO ได้ที่ StableHLO - ceil

Cholesky

ดูเพิ่มเติม XlaBuilder::Cholesky

คำนวณ การแยกตัวประกอบ Cholesky ของเมทริกซ์บวกแน่นอนแบบสมมาตร (Hermitian)

Cholesky(a, lower)

หาก lower เป็น true จะคำนวณเมทริกซ์สามเหลี่ยมล่าง l โดยที่ $a = l . l^T$. If lower is false, computes upper-triangular matrices u such that \(a = u^T . u\).

ระบบจะอ่านข้อมูลอินพุตจากสามเหลี่ยมล่าง/บนของ a เท่านั้น โดยขึ้นอยู่กับค่าของ lower ระบบจะไม่สนใจค่าจากสามเหลี่ยมอีกรูป ข้อมูลเอาต์พุตจะ แสดงในสามเหลี่ยมเดียวกัน ส่วนค่าในสามเหลี่ยมอีกด้านหนึ่งจะ ขึ้นอยู่กับการติดตั้งใช้งานและอาจเป็นค่าใดก็ได้

หาก a มีมิติข้อมูลมากกว่า 2 รายการ ระบบจะถือว่า a เป็นกลุ่มเมทริกซ์ โดยที่มิติข้อมูลทั้งหมด ยกเว้นมิติข้อมูล 2 รายการย่อย เป็นมิติข้อมูลกลุ่ม

หาก a ไม่ใช่เมทริกซ์สมมาตร (Hermitian) ที่เป็นบวกแน่นอน ผลลัพธ์จะขึ้นอยู่กับการใช้งาน

ดูข้อมูล StableHLO ได้ที่ StableHLO - cholesky

เครื่องมือบีบอัด

ดูเพิ่มเติม XlaBuilder::Clamp

จำกัดตัวถูกดำเนินการให้อยู่ในช่วงระหว่างค่าต่ำสุดและสูงสุด

Clamp(min, operand, max)

เมื่อระบุตัวถูกดำเนินการ ค่าต่ำสุด และค่าสูงสุด ฟังก์ชันจะแสดงผลตัวถูกดำเนินการหากอยู่ในช่วงระหว่างค่าต่ำสุดและค่าสูงสุด หรือแสดงผลค่าต่ำสุดหากตัวถูกดำเนินการต่ำกว่าช่วงนี้ หรือแสดงผลค่าสูงสุดหากตัวถูกดำเนินการสูงกว่าช่วงนี้ นั่นคือ clamp(a, x, b) = min(max(a, x), b)

อาร์เรย์ทั้ง 3 ต้องมีรูปร่างเหมือนกัน หรือในรูปแบบที่จำกัดของการออกอากาศ min และ/หรือ max อาจเป็นสเกลาร์ของประเภท T

ตัวอย่างที่มีสเกลาร์ min และ max

let operand: s32[3] = {-1, 5, 9};
let min: s32 = 0;
let max: s32 = 6;
==>
Clamp(min, operand, max) = s32[3]{0, 5, 6};

ดูข้อมูล StableHLO ได้ที่ StableHLO - clamp

ยุบ

ดูเพิ่มเติม XlaBuilder::Collapse และtf.reshape

ยุบมิติข้อมูลของอาร์เรย์เป็นมิติข้อมูลเดียว

Collapse(operand, dimensions)

Collapse จะแทนที่เซ็ตย่อยของมิติข้อมูลของตัวถูกดำเนินการด้วยมิติข้อมูลเดียว อาร์กิวเมนต์อินพุตคืออาร์เรย์ที่กำหนดเองของประเภท T และเวกเตอร์ค่าคงที่ที่คอมไพล์ในเวลาเรียกใช้ของดัชนีมิติข้อมูล ดัชนีมิติข้อมูลต้องเป็น ชุดย่อยต่อเนื่องของมิติข้อมูลของ T ตามลำดับ (หมายเลขมิติข้อมูลจากต่ำไปสูง) ดังนั้น {0, 1, 2}, {0, 1} หรือ {1, 2} จึงเป็นชุดมิติข้อมูลที่ถูกต้องทั้งหมด แต่ {1, 0} หรือ {0, 2} ไม่ถูกต้อง ระบบจะแทนที่ด้วยมิติข้อมูลใหม่รายการเดียวใน ตำแหน่งเดียวกันในลําดับมิติข้อมูลกับมิติข้อมูลที่แทนที่ โดยมี ขนาดมิติข้อมูลใหม่เท่ากับผลคูณของขนาดมิติข้อมูลเดิม หมายเลขมิติข้อมูลที่ต่ำที่สุดใน dimensions คือมิติข้อมูลที่มีการเปลี่ยนแปลงช้าที่สุด (สำคัญที่สุด) ในลูปที่ซ้อนกันซึ่งยุบมิติข้อมูลเหล่านี้ และหมายเลขมิติข้อมูลที่สูงที่สุด คือมิติข้อมูลที่มีการเปลี่ยนแปลงเร็วที่สุด (เล็กที่สุด) ดูตัวดำเนินการ tf.reshape หากต้องการ การจัดลำดับการยุบข้อมูลทั่วไปเพิ่มเติม

ตัวอย่างเช่น สมมติว่า v เป็นอาร์เรย์ที่มี 24 องค์ประกอบ

let v = f32[4x2x3] { { {10, 11, 12}, {15, 16, 17} },
{ {20, 21, 22}, {25, 26, 27} },
{ {30, 31, 32}, {35, 36, 37} },
{ {40, 41, 42}, {45, 46, 47} } };

// Collapse to a single dimension, leaving one dimension.
let v012 = Collapse(v, {0,1,2});
then v012 == f32[24] {10, 11, 12, 15, 16, 17,
20, 21, 22, 25, 26, 27,
30, 31, 32, 35, 36, 37,
40, 41, 42, 45, 46, 47};

// Collapse the two lower dimensions, leaving two dimensions.
let v01 = Collapse(v, {0,1});
then v01 == f32[4x6] { {10, 11, 12, 15, 16, 17},
{20, 21, 22, 25, 26, 27},
{30, 31, 32, 35, 36, 37},
{40, 41, 42, 45, 46, 47} };

// Collapse the two higher dimensions, leaving two dimensions.
let v12 = Collapse(v, {1,2});
then v12 == f32[8x3] { {10, 11, 12},
{15, 16, 17},
{20, 21, 22},
{25, 26, 27},
{30, 31, 32},
{35, 36, 37},
{40, 41, 42},
{45, 46, 47} };

Clz

ดูเพิ่มเติม XlaBuilder::Clz

นับเลข 0 นำหน้าแบบทีละองค์ประกอบ

Clz(operand)

CollectiveBroadcast

ดูเพิ่มเติม XlaBuilder::CollectiveBroadcast

กระจายข้อมูลไปยังรีพลิกาทั้งหมด ระบบจะส่งข้อมูลจากรหัสสำเนาแรกในแต่ละกลุ่มไปยังรหัสอื่นๆ ในกลุ่มเดียวกัน หากรหัสรีพลิกาไม่ได้อยู่ในกลุ่มรีพลิกาใดๆ เอาต์พุตในรีพลิกานั้นจะเป็นเทนเซอร์ที่ประกอบด้วย 0 ใน shape

CollectiveBroadcast(operand, replica_groups, channel_id)

ดูข้อมูล StableHLO ได้ที่ StableHLO - collective_broadcast

CollectivePermute

ดูเพิ่มเติม XlaBuilder::CollectivePermute

CollectivePermute เป็นการดำเนินการแบบกลุ่มที่ส่งและรับข้อมูลในรีพลิกา

CollectivePermute(operand, source_target_pairs, channel_id, inplace)

โปรดทราบว่าsource_target_pairs มีข้อจำกัดต่อไปนี้

• คู่ใดๆ 2 คู่ไม่ควรมีรหัสรีเพลสเป้าหมายเดียวกัน และไม่ควรมีรหัสรีเพลสต้นทางเดียวกัน
• หากรหัสรีพลิกาไม่ใช่เป้าหมายในคู่ใดๆ เอาต์พุตในรีพลิกานั้น จะเป็นเทนเซอร์ที่ประกอบด้วย 0 ที่มีรูปร่างเหมือนกับอินพุต

API ของการดำเนินการ CollectivePermute จะแยกออกเป็นคำสั่ง HLO 2 รายการภายใน (CollectivePermuteStart และ CollectivePermuteDone)

ดูเพิ่มเติม HloInstruction::CreateCollectivePermuteStart

CollectivePermuteStart และ CollectivePermuteDone ทำหน้าที่เป็นองค์ประกอบพื้นฐานใน HLO การดำเนินการเหล่านี้อาจปรากฏในข้อมูลการทิ้ง HLO แต่ไม่ได้มีไว้ให้ผู้ใช้ปลายทางสร้างขึ้นด้วยตนเอง

ดูข้อมูล StableHLO ได้ที่ StableHLO - collective_permute

เปรียบเทียบ

ดูเพิ่มเติม XlaBuilder::Compare

ดำเนินการเปรียบเทียบแบบทีละองค์ประกอบของ lhs และ rhs ของรายการต่อไปนี้

Eq

ดูเพิ่มเติม XlaBuilder::Eq

ทำการเปรียบเทียบเท่ากับแบบทีละองค์ประกอบของ lhs และ rhs

\(lhs = rhs\)

Eq(lhs, rhs)

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

มีตัวแปรอื่นที่รองรับการออกอากาศแบบหลายมิติ สำหรับ Eq ดังนี้

Eq(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

รองรับยอดสั่งซื้อทั้งหมดที่มากกว่าจำนวนทศนิยมสำหรับ Eq โดยการบังคับใช้สิ่งต่อไปนี้

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

EqTotalOrder(lhs,rhs, broadcast_dimensions)

ดูข้อมูล StableHLO ได้ที่ StableHLO - เปรียบเทียบ

Ne

ดูเพิ่มเติม XlaBuilder::Ne

ดำเนินการเปรียบเทียบไม่เท่ากับแบบทีละองค์ประกอบของ lhs และ rhs

\(lhs != rhs\)

Ne(lhs, rhs)

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

สำหรับ Ne จะมีตัวเลือกอื่นที่รองรับการออกอากาศแบบหลายมิติ

Ne(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

รองรับยอดสั่งซื้อทั้งหมดที่มากกว่าจำนวนจุดลอยตัวสำหรับ Ne โดย บังคับใช้ดังนี้

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

NeTotalOrder(lhs,rhs, broadcast_dimensions)

ดูข้อมูล StableHLO ได้ที่ StableHLO - เปรียบเทียบ

Ge

ดูเพิ่มเติม XlaBuilder::Ge

ดำเนินการเปรียบเทียบgreater-or-equal-thanแบบทีละองค์ประกอบของ lhs และ rhs

\(lhs >= rhs\)

Ge(lhs, rhs)

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

สำหรับ Ge จะมีตัวแปรอื่นที่รองรับการออกอากาศแบบหลายมิติ

Ge(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

รองรับคำสั่งซื้อทั้งหมดที่มากกว่าตัวเลขทศนิยมสำหรับ Gt โดยการบังคับใช้สิ่งต่อไปนี้

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

GtTotalOrder(lhs,rhs, broadcast_dimensions)

ดูข้อมูล StableHLO ได้ที่ StableHLO - เปรียบเทียบ

Gt

ดูเพิ่มเติม XlaBuilder::Gt

เปรียบเทียบ lhs กับ rhs แบบทีละองค์ประกอบโดยใช้ตัวดำเนินการมากกว่า

\(lhs > rhs\)

Gt(lhs, rhs)

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

Gt มีตัวแปรอื่นที่รองรับการออกอากาศแบบหลายมิติ

Gt(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - เปรียบเทียบ

Le

ดูเพิ่มเติม XlaBuilder::Le

ทำการเปรียบเทียบless-or-equal-thanแบบทีละองค์ประกอบของ lhs และ rhs

\(lhs <= rhs\)

Le(lhs, rhs)

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

Le มีเวอร์ชันอื่นที่รองรับการออกอากาศแบบหลายมิติ

Le(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

รองรับคำสั่งซื้อทั้งหมดที่มากกว่าจำนวนจุดทศนิยมสำหรับ Le โดยการบังคับใช้สิ่งต่อไปนี้

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

LeTotalOrder(lhs,rhs, broadcast_dimensions)

ดูข้อมูล StableHLO ได้ที่ StableHLO - เปรียบเทียบ

Lt

ดูเพิ่มเติม XlaBuilder::Lt

ดำเนินการเปรียบเทียบแบบองค์ประกอบต่อองค์ประกอบของ lhs และ rhs โดยใช้ฟังก์ชันน้อยกว่า

\(lhs < rhs\)

Lt(lhs, rhs)

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

มีตัวแปรอื่นที่รองรับการออกอากาศแบบหลายมิติ สำหรับ Lt ดังนี้

Lt(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

รองรับคำสั่งซื้อทั้งหมดที่มากกว่าตัวเลขทศนิยมสำหรับ Lt โดยการบังคับใช้สิ่งต่อไปนี้

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

LtTotalOrder(lhs,rhs, broadcast_dimensions)

ดูข้อมูล StableHLO ได้ที่ StableHLO - เปรียบเทียบ

ซับซ้อน

ดูเพิ่มเติม XlaBuilder::Complex

ทำการแปลงค่าแบบทีละองค์ประกอบเป็นค่าเชิงซ้อนจากคู่ค่าจริงและค่าจินตภาพ lhs และ rhs

Complex(lhs, rhs)

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

Complex มีตัวเลือกอื่นที่รองรับการออกอากาศแบบหลายมิติ

Complex(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - complex

ConcatInDim (เชื่อมต่อ)

ดูเพิ่มเติม XlaBuilder::ConcatInDim

Concatenate จะสร้างอาร์เรย์จากตัวถูกดำเนินการที่เป็นอาร์เรย์หลายรายการ อาร์เรย์มีจำนวนมิติข้อมูลเท่ากับตัวถูกดำเนินการของอาร์เรย์อินพุตแต่ละตัว (ซึ่งต้องมีจำนวนมิติข้อมูลเท่ากัน) และมีอาร์กิวเมนต์ตามลำดับที่ระบุ

Concatenate(operands..., dimension)

มิติข้อมูลทั้งหมดต้องเหมือนกัน ยกเว้น dimension เนื่องจาก XLA ไม่รองรับอาร์เรย์ "ไม่สม่ำเสมอ" นอกจากนี้ โปรดทราบว่าคุณจะต่อค่า 0 มิติไม่ได้ (เนื่องจากตั้งชื่อมิติข้อมูลที่ใช้ต่อไม่ได้)

ตัวอย่าง 1 มิติ

Concat({ {2, 3}, {4, 5}, {6, 7} }, 0)
//Output:  {2, 3, 4, 5, 6, 7}

ตัวอย่าง 2 มิติ

let a = { {1, 2},
         {3, 4},
         {5, 6} };

let b = { {7, 8} };

Concat({a, b}, 0)

//Output:  { {1, 2},
//          {3, 4},
//          {5, 6},
//          {7, 8} }

แผนภาพ

ดูข้อมูล StableHLO ได้ที่ StableHLO - concatenate

มีเงื่อนไข

ดูเพิ่มเติม XlaBuilder::Conditional

Conditional(predicate, true_operand, true_computation, false_operand, false_computation)

เรียกใช้ true_computation หาก predicate เป็น true, false_computation หาก predicate เป็น false และแสดงผลลัพธ์

true_computation ต้องรับอาร์กิวเมนต์เดียวประเภท \(T_0\) และจะ เรียกใช้ด้วย true_operand ซึ่งต้องเป็นประเภทเดียวกัน false_computation ต้องรับอาร์กิวเมนต์เดียวประเภท \(T_1\) และจะเรียกใช้ด้วย false_operand ซึ่งต้องเป็นประเภทเดียวกัน ประเภทของ ค่าที่แสดงผลของ true_computation และ false_computation ต้องเหมือนกัน

โปรดทราบว่าระบบจะเรียกใช้ true_computation หรือ false_computation เพียงอย่างเดียว โดยขึ้นอยู่กับค่าของ predicate

Conditional(branch_index, branch_computations, branch_operands)

เรียกใช้ branch_computations[branch_index] และแสดงผลลัพธ์ หาก branch_index เป็น S32 ซึ่งมีค่าน้อยกว่า 0 หรือมากกว่าหรือเท่ากับ N ระบบจะเรียกใช้ branch_computations[N-1] เป็นกิ่งก้านเริ่มต้น

branch_computations[b] แต่ละรายการต้องรับอาร์กิวเมนต์เดียวของประเภท \(T_b\) และ จะเรียกใช้ด้วย branch_operands[b] ซึ่งต้องเป็นประเภทเดียวกัน ประเภทของค่าที่แสดงผลของแต่ละ branch_computations[b] ต้องเหมือนกัน

โปรดทราบว่าระบบจะเรียกใช้เพียง 1 รายการใน branch_computations โดยขึ้นอยู่กับค่าของ branch_index

ดูข้อมูล StableHLO ได้ที่ StableHLO - if

ค่าคงที่

ดูเพิ่มเติม XlaBuilder::ConstantLiteral

สร้าง output จากค่าคงที่ literal

Constant(literal)

ดูข้อมูล StableHLO ได้ที่ StableHLO - constant

ConvertElementType

ดูเพิ่มเติม XlaBuilder::ConvertElementType

ConvertElementType จะดำเนินการแปลงทีละองค์ประกอบจากรูปร่างข้อมูลไปยังรูปร่างเป้าหมาย เช่นเดียวกับ static_cast ใน C++ มิติข้อมูลต้องตรงกัน และ Conversion เป็นแบบทีละองค์ประกอบ เช่น s32 องค์ประกอบจะกลายเป็น f32 องค์ประกอบผ่านกิจวัตรการแปลงจาก s32 เป็น f32

ConvertElementType(operand, new_element_type)

มิติข้อมูลของตัวถูกดำเนินการและรูปร่างเป้าหมายต้องตรงกัน ประเภทองค์ประกอบต้นทางและปลายทางต้องไม่ใช่ Tuple

Conversion เช่น T=s32 เป็น U=f32 จะเรียกใช้การแปลง int เป็น float ตามปกติ เช่น การปัดเศษเป็นจำนวนคู่ที่ใกล้ที่สุด

let a: s32[3] = {0, 1, 2};
let b: f32[3] = convert(a, f32);
then b == f32[3]{0.0, 1.0, 2.0}

ดูข้อมูล StableHLO ได้ที่StableHLO - convert

Conv (Convolution)

ดูเพิ่มเติม XlaBuilder::Conv

คำนวณการสังวัตนาการประเภทที่ใช้ในโครงข่ายประสาทเทียม ในที่นี้ เราอาจมองว่าการสังวัตนาการ คือหน้าต่าง n มิติที่เคลื่อนที่ผ่านพื้นที่ฐาน n มิติ และมีการคำนวณสำหรับตำแหน่งที่เป็นไปได้ทั้งหมดของหน้าต่าง

Conv จัดคิวคำสั่งการแปลงเป็นภาพลงในการคำนวณ ซึ่งใช้ หมายเลขมิติข้อมูลการแปลงเป็นภาพเริ่มต้นโดยไม่มีการขยาย

โดยจะระบุการเพิ่มแพดดิ้งในรูปแบบย่อเป็น SAME หรือ VALID การเพิ่มแพดดิ้ง SAME จะเพิ่มค่า 0 ให้กับอินพุต (lhs) เพื่อให้เอาต์พุตมีรูปร่างเหมือนกับอินพุต เมื่อไม่พิจารณาการก้าวกระโดด VALID padding หมายถึง ไม่มีการเพิ่มระยะห่างจากขอบ

Conv(lhs, rhs, window_strides, padding, feature_group_count, batch_group_count, precision_config, preferred_element_type)

Conv มีการควบคุมในระดับต่างๆ ดังนี้

• ConvWithGeneralPadding
• ConvWithGeneralDimensions
• ConvGeneral
• ConvGeneralDilated

ให้ n เป็นจำนวนมิติเชิงพื้นที่ อาร์กิวเมนต์ lhs คืออาร์เรย์ (n+2) มิติที่อธิบายพื้นที่ฐาน ซึ่งเรียกว่าอินพุต แม้ว่าแน่นอนว่า rhs ก็เป็นอินพุตด้วย ในโครงข่ายประสาทเทียม สิ่งเหล่านี้คือ การเปิดใช้งานอินพุต มิติข้อมูล n+2 ตามลำดับมีดังนี้

• batch: พิกัดแต่ละรายการในมิติข้อมูลนี้แสดงอินพุตอิสระ ซึ่งใช้ดำเนินการ Convolution
• z/depth/features: ตำแหน่ง (y,x) แต่ละตำแหน่งในพื้นที่ฐานมีเวกเตอร์ ที่เชื่อมโยงอยู่ ซึ่งจะอยู่ในมิติข้อมูลนี้
• spatial_dims: อธิบายnมิติเชิงพื้นที่ที่กำหนดพื้นที่ฐาน ซึ่งหน้าต่างเคลื่อนที่ผ่าน

อาร์กิวเมนต์ rhs คืออาร์เรย์ (n+2) มิติที่อธิบายตัวกรอง/เคอร์เนล/หน้าต่าง การแปลง มิติข้อมูลเรียงตามลำดับต่อไปนี้

• output-z: มิติข้อมูล z ของเอาต์พุต
• input-z: ขนาดของมิติข้อมูลนี้คูณด้วย feature_group_count ควร เท่ากับขนาดของมิติข้อมูล z ใน lhs
• spatial_dims: อธิบายnมิติเชิงพื้นที่ที่กำหนดหน้าต่าง n-d ซึ่งเคลื่อนที่ไปทั่วพื้นที่ฐาน

อาร์กิวเมนต์ window_strides จะระบุระยะก้าวกระโดดของหน้าต่างการแปลง ในมิติเชิงพื้นที่ ตัวอย่างเช่น หากระยะก้าวย่างในมิติเชิงพื้นที่แรกคือ 3 ระบบจะวางหน้าต่างได้เฉพาะที่พิกัดซึ่งดัชนีเชิงพื้นที่แรกหารด้วย 3 ลงตัว

อาร์กิวเมนต์ padding ระบุจำนวนการเพิ่ม 0 ที่จะใช้กับ พื้นที่ฐาน จำนวนการเพิ่มขอบอาจเป็นค่าลบได้ โดยค่าสัมบูรณ์ของการเพิ่มขอบที่เป็นค่าลบจะระบุจำนวนองค์ประกอบที่จะนำออกจากมิติข้อมูลที่ระบุก่อนทำการ Convolution padding[0] ระบุระยะขอบสำหรับมิติข้อมูล y และ padding[1] ระบุระยะขอบสำหรับมิติข้อมูล x แต่ละคู่มีระยะเว้นต่ำเป็นองค์ประกอบแรกและระยะเว้นสูงเป็นองค์ประกอบที่สอง ระบบจะใช้การเว้นวรรคต่ำในทิศทางของดัชนีที่ต่ำกว่า ส่วนการเว้นวรรคสูงจะใช้ในทิศทางของดัชนีที่สูงกว่า เช่น หาก padding[1] เป็น (2,3) จะมีการเพิ่ม 0 จำนวน 2 ตัวทางด้านซ้ายและ 0 จำนวน 3 ตัวทางด้านขวาในมิติเชิงพื้นที่ที่ 2 การใช้การเพิ่มระยะห่างจากขอบ เทียบเท่ากับการแทรกค่าศูนย์เดียวกันเหล่านั้นลงในอินพุต (lhs) ก่อน ทำการสังวัตนาการ

อาร์กิวเมนต์ lhs_dilation และ rhs_dilation จะระบุปัจจัยการขยายที่จะใช้กับ lhs และ rhs ตามลำดับในแต่ละมิติเชิงพื้นที่ หาก dilation factor ในมิติเชิงพื้นที่คือ d จะมีการวางรู d-1 โดยนัย ระหว่างแต่ละรายการในมิตินั้น ซึ่งจะเพิ่มขนาดของ อาร์เรย์ โดยจะเติมค่าที่ไม่มีการดำเนินการลงในช่องว่าง ซึ่งสำหรับการ Convolution จะหมายถึง ค่า 0

การขยาย rhs เรียกอีกอย่างว่าการสังวัตน์แบบ Atrous ดูรายละเอียดเพิ่มเติมได้ที่ tf.nn.atrous_conv2d การขยายของ lhs เรียกอีกอย่างว่า การแปลงผกผัน ดูรายละเอียดเพิ่มเติมได้ที่ tf.nn.conv2d_transpose

อาร์กิวเมนต์ feature_group_count (ค่าเริ่มต้นคือ 1) ใช้ได้กับการ Convolution แบบจัดกลุ่ม feature_group_count ต้องเป็นตัวหารของทั้งมิติข้อมูลอินพุตและ มิติข้อมูลฟีเจอร์เอาต์พุต หาก feature_group_count มากกว่า 1 แสดงว่ามิติข้อมูลฟีเจอร์อินพุตและเอาต์พุต รวมถึงมิติข้อมูลฟีเจอร์เอาต์พุต rhs จะแบ่งออกเป็นหลายกลุ่ม feature_group_count อย่างเท่าๆ กัน โดยแต่ละกลุ่มประกอบด้วยลำดับย่อยของฟีเจอร์ที่ต่อเนื่องกัน มิติข้อมูลฟีเจอร์อินพุตของ rhs ต้องเท่ากับมิติข้อมูลฟีเจอร์อินพุตของ lhs หารด้วย feature_group_count (ดังนั้นจึงมีขนาดเท่ากับกลุ่มฟีเจอร์อินพุตอยู่แล้ว) กลุ่มที่ i จะใช้ร่วมกันเพื่อคำนวณ feature_group_countสำหรับการผสานหลายรายการแยกกัน ผลลัพธ์ของการ Convolutions เหล่านี้จะต่อกันในมิติข้อมูลฟีเจอร์เอาต์พุต

สำหรับการผันแปรแบบแยกความลึก ระบบจะตั้งค่าอาร์กิวเมนต์ feature_group_count เป็นมิติข้อมูลฟีเจอร์อินพุต และจะเปลี่ยนรูปร่างตัวกรองจาก [filter_height, filter_width, in_channels, channel_multiplier] เป็น [filter_height, filter_width, 1, in_channels * channel_multiplier] ดูรายละเอียดเพิ่มเติมได้ที่ tf.nn.depthwise_conv2d

อาร์กิวเมนต์ batch_group_count (ค่าเริ่มต้นคือ 1) สามารถใช้กับตัวกรองที่จัดกลุ่ม ระหว่างการส่งผ่านข้อมูลย้อนกลับ batch_group_count ต้องเป็นตัวหารของขนาดมิติข้อมูลกลุ่ม lhs (อินพุต) หาก batch_group_count มากกว่า 1 แสดงว่ามิติข้อมูลกลุ่มเอาต์พุตควรมีขนาด input batch / batch_group_count batch_group_count ต้องเป็นตัวหารของขนาดฟีเจอร์เอาต์พุต

รูปร่างเอาต์พุตมีมิติข้อมูลต่อไปนี้ตามลำดับ

• batch: ขนาดของมิติข้อมูลนี้คูณด้วย batch_group_count ควรเท่ากับขนาดของมิติข้อมูล batch ใน lhs
• z: มีขนาดเท่ากับ output-z ในเคอร์เนล (rhs)
• spatial_dims: ค่า 1 ค่าสำหรับตําแหน่งที่ถูกต้องแต่ละตําแหน่งของหน้าต่าง Convolutional

รูปภาพด้านบนแสดงวิธีการทำงานของช่อง batch_group_count กล่าวคือ เราจะแบ่งกลุ่มแบตช์ lhs แต่ละรายการออกเป็น batch_group_count กลุ่ม และทำเช่นเดียวกันกับฟีเจอร์เอาต์พุต จากนั้นเราจะทำการสังวัตนาการแบบเป็นคู่สำหรับแต่ละกลุ่มเหล่านี้ และ ต่อเอาต์พุตตามมิติข้อมูลฟีเจอร์เอาต์พุต ความหมายเชิงปฏิบัติการ ของมิติข้อมูลอื่นๆ ทั้งหมด (ฟีเจอร์และเชิงพื้นที่) จะยังคงเหมือนเดิม

การวางหน้าต่าง Convolution ที่ถูกต้องจะกำหนดโดย Strides และขนาดของพื้นที่ฐานหลังจากการเพิ่ม Padding

หากต้องการอธิบายว่า Convolution ทำอะไร ให้พิจารณา Convolution แบบ 2 มิติ แล้วเลือกพิกัด batch, z, y, x ที่คงที่ในเอาต์พุต จากนั้น (y,x) คือ ตำแหน่งของมุมหน้าต่างภายในพื้นที่ฐาน (เช่น มุมซ้ายบน ขึ้นอยู่กับวิธีตีความมิติเชิงพื้นที่) ตอนนี้เรามีหน้าต่าง 2 มิติ ที่ได้จากพื้นที่ฐาน ซึ่งแต่ละจุด 2 มิติเชื่อมโยงกับเวกเตอร์ 1 มิติ เราจึงได้กล่อง 3 มิติ จากเคอร์เนลแบบ Convolutional เนื่องจากเราแก้ไขพิกัดเอาต์พุต z เราจึงมีกล่อง 3 มิติด้วย กล่องทั้ง 2 มีขนาดเท่ากัน ดังนั้นเราจึงนำผลคูณแบบทีละองค์ประกอบระหว่างกล่องทั้ง 2 มาบวกกันได้ (คล้ายกับผลคูณแบบดอท) ซึ่งเป็นค่าเอาต์พุต

โปรดทราบว่าหาก output-z เป็น เช่น 5 จากนั้นแต่ละตำแหน่งของหน้าต่างจะสร้างค่า 5 ค่าในเอาต์พุตลงในzมิติข้อมูลของเอาต์พุต ค่าเหล่านี้แตกต่างกัน ในส่วนของเคอร์เนล Convolutional ที่ใช้ โดยมีกล่อง 3 มิติแยกต่างหากของ ค่าที่ใช้สำหรับพิกัด output-z แต่ละค่า ดังนั้น คุณอาจคิดว่าเป็นการทำ Convolution แยกกัน 5 ครั้งโดยใช้ฟิลเตอร์ที่แตกต่างกันสำหรับแต่ละครั้ง

ต่อไปนี้คือโค้ดจำลองสำหรับการสังวัตนาการ 2 มิติที่มีการเพิ่ม Padding และ Striding

for (b, oz, oy, ox) { // output coordinates
  value = 0;
  for (iz, ky, kx) { // kernel coordinates and input z
    iy = oy*stride_y + ky - pad_low_y;
    ix = ox*stride_x + kx - pad_low_x;
    if ((iy, ix) inside the base area considered without padding) {
      value += input(b, iz, iy, ix) * kernel(oz, iz, ky, kx);
    }
  }
  output(b, oz, oy, ox) = value;
}

precision_config ใช้เพื่อระบุการกำหนดค่าความแม่นยำ ระดับ จะกำหนดว่าฮาร์ดแวร์ควรพยายามสร้างคำสั่งโค้ดเครื่องเพิ่มเติม เพื่อจำลอง dtype ได้แม่นยำยิ่งขึ้นเมื่อจำเป็นหรือไม่ (เช่น จำลอง f32 ใน TPU ที่รองรับเฉพาะ bf16 matmuls) ค่าอาจเป็น DEFAULT, HIGH, HIGHEST รายละเอียดเพิ่มเติม ในส่วน MXU

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

ดูข้อมูล StableHLO ได้ที่ StableHLO - การสังวัตนาการ

ConvWithGeneralPadding

ดูเพิ่มเติม XlaBuilder::ConvWithGeneralPadding

ConvWithGeneralPadding(lhs, rhs, window_strides, padding, feature_group_count, batch_group_count, precision_config, preferred_element_type)

เช่นเดียวกับ Conv ที่มีการกำหนดค่าการเพิ่มพื้นที่อย่างชัดเจน

ConvWithGeneralDimensions

ดูเพิ่มเติม XlaBuilder::ConvWithGeneralDimensions

ConvWithGeneralDimensions(lhs, rhs, window_strides, padding, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type)

เช่นเดียวกับ Conv ที่ระบุหมายเลขมิติข้อมูลอย่างชัดเจน

ConvGeneral

ดูเพิ่มเติม XlaBuilder::ConvGeneral

ConvGeneral(lhs, rhs, window_strides, padding, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type)

เช่นเดียวกับ Conv ที่มีการกำหนดหมายเลขมิติข้อมูลและการกำหนดค่าระยะห่างจากขอบอย่างชัดเจน

ConvGeneralDilated

ดูเพิ่มเติม XlaBuilder::ConvGeneralDilated

ConvGeneralDilated(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type, window_reversal)

เช่นเดียวกับ Conv ซึ่งมีการกำหนดค่าการเพิ่มระยะขอบ ค่าการขยาย และหมายเลขมิติข้อมูลอย่างชัดเจน

คัดลอก

ดูเพิ่มเติม HloInstruction::CreateCopyStart

Copy จะแยกย่อยภายในเป็นคำสั่ง HLO 2 รายการ ได้แก่ CopyStart และ CopyDone Copy รวมถึง CopyStart และ CopyDone ทำหน้าที่เป็นองค์ประกอบพื้นฐานใน HLO การดำเนินการเหล่านี้อาจปรากฏในการดัมพ์ HLO แต่ไม่ได้มีไว้ให้ผู้ใช้ปลายทางสร้างขึ้นด้วยตนเอง

Cos

ดูXlaBuilder::Cosด้วย

โคไซน์แบบองค์ประกอบต่อองค์ประกอบ x -> cos(x)

Cos(operand)

นอกจากนี้ Cos ยังรองรับอาร์กิวเมนต์ result_accuracy ที่ไม่บังคับด้วย

Cos(operand, result_accuracy)

ดูข้อมูลเพิ่มเติมเกี่ยวกับ result_accuracy ได้ที่ ความถูกต้องของผลลัพธ์

ดูข้อมูล StableHLO ได้ที่ StableHLO - โคไซน์

Cosh

ดูเพิ่มเติม XlaBuilder::Cosh

ไฮเพอร์โบลิกโคไซน์แบบองค์ประกอบต่อองค์ประกอบ x -> cosh(x)

Cosh(operand)

นอกจากนี้ Cosh ยังรองรับอาร์กิวเมนต์ result_accuracy ที่ไม่บังคับด้วย

Cosh(operand, result_accuracy)

ดูข้อมูลเพิ่มเติมเกี่ยวกับ result_accuracy ได้ที่ ความถูกต้องของผลลัพธ์

CustomCall

ดูเพิ่มเติม XlaBuilder::CustomCall

เรียกใช้ฟังก์ชันที่ผู้ใช้ระบุภายในการคำนวณ

เอกสารประกอบเกี่ยวกับ CustomCall มีอยู่ใน รายละเอียดสำหรับนักพัฒนาซอฟต์แวร์ - XLA Custom Calls

ดูข้อมูล StableHLO ได้ที่ StableHLO - custom_call

Div

ดูเพิ่มเติม XlaBuilder::Div

ทำการหารแบบทีละองค์ประกอบของตัวตั้ง lhs และตัวหาร rhs

Div(lhs, rhs)

การล้นของการหารจำนวนเต็ม (การหาร/เศษที่ลงชื่อ/ไม่ได้ลงชื่อด้วย 0 หรือการหาร/เศษที่ลงชื่อของ INT_SMIN ด้วย -1) จะสร้างค่าที่กำหนดการใช้งาน

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

Div มีตัวเลือกอื่นที่รองรับการออกอากาศแบบหลายมิติ

Div(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - divide

โดเมน

ดูเพิ่มเติม HloInstruction::CreateDomain

Domain อาจปรากฏในข้อมูลการทิ้ง HLO แต่ไม่ได้มีไว้ให้ผู้ใช้ปลายทางสร้างขึ้นด้วยตนเอง

จุด

ดูเพิ่มเติม XlaBuilder::Dot

Dot(lhs, rhs, precision_config, preferred_element_type)

ความหมายที่แน่นอนของการดำเนินการนี้ขึ้นอยู่กับอันดับของตัวถูกดำเนินการ

การดำเนินการจะหาผลรวมของผลิตภัณฑ์ในมิติที่ 2 ของ lhs (หรือมิติแรกหากมี 1 มิติ) และมิติแรกของ rhs ซึ่งเป็นมิติข้อมูลที่ "ทำสัญญา" มิติข้อมูลที่ทำสัญญาของ lhs และ rhs ต้องมีขนาดเท่ากัน ในทางปฏิบัติ ฟังก์ชันนี้สามารถใช้เพื่อดำเนินการดอทโปรดักต์ระหว่าง เวกเตอร์ การคูณเวกเตอร์/เมทริกซ์ หรือการคูณเมทริกซ์/เมทริกซ์

precision_config ใช้เพื่อระบุการกำหนดค่าความแม่นยำ ระดับ จะกำหนดว่าฮาร์ดแวร์ควรพยายามสร้างคำสั่งโค้ดเครื่องเพิ่มเติม เพื่อจำลอง dtype ได้แม่นยำยิ่งขึ้นเมื่อจำเป็นหรือไม่ (เช่น จำลอง f32 ใน TPU ที่รองรับเฉพาะ bf16 matmuls) ค่าอาจเป็น DEFAULT, HIGH, HIGHEST รายละเอียดเพิ่มเติม ในส่วน MXU

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

ดูข้อมูล StableHLO ได้ที่ StableHLO - dot

DotGeneral

ดูเพิ่มเติม XlaBuilder::DotGeneral

DotGeneral(lhs, rhs, dimension_numbers, precision_config, preferred_element_type)

คล้ายกับ Dot แต่ช่วยให้ระบุหมายเลขมิติข้อมูลแบบย่อและแบบกลุ่มได้สำหรับทั้ง lhs และ rhs

DotGeneral จะดำเนินการหาผลรวมของผลิตภัณฑ์ในมิติข้อมูลการทำสัญญาที่ระบุใน dimension_numbers

หมายเลขมิติข้อมูลการทำสัญญาที่เชื่อมโยงจาก lhs และ rhs ไม่จำเป็นต้อง เหมือนกัน แต่ต้องมีขนาดมิติข้อมูลเดียวกัน

ตัวอย่างที่มีหมายเลขมิติข้อมูลการทำสัญญา

lhs = { {1.0, 2.0, 3.0},
        {4.0, 5.0, 6.0} }

rhs = { {1.0, 1.0, 1.0},
        {2.0, 2.0, 2.0} }

DotDimensionNumbers dnums;
dnums.add_lhs_contracting_dimensions(1);
dnums.add_rhs_contracting_dimensions(1);

DotGeneral(lhs, rhs, dnums) -> { { 6.0, 12.0},
                                 {15.0, 30.0} }

หมายเลขมิติข้อมูลกลุ่มที่เชื่อมโยงจาก lhs และ rhs ต้องมีขนาดมิติข้อมูลเดียวกัน

ตัวอย่างที่มีหมายเลขมิติข้อมูลกลุ่ม (ขนาดกลุ่ม 2, เมทริกซ์ 2x2)

lhs = { { {1.0, 2.0},
          {3.0, 4.0} },
        { {5.0, 6.0},
          {7.0, 8.0} } }

rhs = { { {1.0, 0.0},
          {0.0, 1.0} },
        { {1.0, 0.0},
          {0.0, 1.0} } }

DotDimensionNumbers dnums;
dnums.add_lhs_contracting_dimensions(2);
dnums.add_rhs_contracting_dimensions(1);
dnums.add_lhs_batch_dimensions(0);
dnums.add_rhs_batch_dimensions(0);

DotGeneral(lhs, rhs, dnums) -> {
    { {1.0, 2.0},
      {3.0, 4.0} },
    { {5.0, 6.0},
      {7.0, 8.0} } }

ดังนั้นหมายเลขมิติข้อมูลที่ได้จะเริ่มต้นด้วยมิติข้อมูลกลุ่ม จากนั้นเป็นมิติข้อมูลlhsที่ไม่ใช่สัญญา/ไม่ใช่กลุ่ม และสุดท้ายคือมิติข้อมูลrhs ที่ไม่ใช่สัญญา/ไม่ใช่กลุ่ม

precision_config ใช้เพื่อระบุการกำหนดค่าความแม่นยำ ระดับ จะกำหนดว่าฮาร์ดแวร์ควรพยายามสร้างคำสั่งโค้ดเครื่องเพิ่มเติม เพื่อจำลอง dtype ได้แม่นยำยิ่งขึ้นเมื่อจำเป็นหรือไม่ (เช่น จำลอง f32 ใน TPU ที่รองรับเฉพาะ bf16 matmuls) ค่าอาจเป็น DEFAULT, HIGH, HIGHEST ดูรายละเอียดเพิ่มเติม ได้ในส่วน MXU

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

ดูข้อมูล StableHLO ได้ที่ StableHLO - dot_general

ScaledDot

ดูเพิ่มเติม XlaBuilder::ScaledDot

ScaledDot(lhs, lhs_scale, rhs, rhs_scale, dimension_number, precision_config,preferred_element_type)

คล้ายกับ DotGeneral

สร้างการดำเนินการ dot ที่ปรับขนาดโดยมีตัวถูกดำเนินการเป็น "lhs", "lhs_scale", "rhs" และ "rhs_scale" โดยมีมิติข้อมูลการทำสัญญาและมิติข้อมูลกลุ่มที่ระบุใน "dimension_numbers"

RaggedDot

ดูเพิ่มเติม XlaBuilder::RaggedDot

ดูรายละเอียดการคำนวณของ RaggedDot ได้ที่ StableHLO - chlo.ragged_dot

DynamicReshape

ดูเพิ่มเติม XlaBuilder::DynamicReshape

การดำเนินการนี้จะเหมือนกับ reshape ในเชิงฟังก์ชัน แต่จะระบุรูปร่างผลลัพธ์แบบไดนามิกผ่าน output_shape

DynamicReshape(operand, dim_sizes, new_size_bounds, dims_are_dynamic)

ดูข้อมูล StableHLO ได้ที่ StableHLO - dynamic_reshape

DynamicSlice

ดูเพิ่มเติม XlaBuilder::DynamicSlice

DynamicSlice จะดึงข้อมูลอาร์เรย์ย่อยจากอาร์เรย์อินพุตที่ dynamic start_indices ระบบจะส่งขนาดของชิ้นในแต่ละมิติข้อมูลใน size_indices ซึ่งระบุจุดสิ้นสุดของช่วงชิ้นแบบไม่รวมในแต่ละมิติข้อมูล: [start, start + size) รูปร่างของ start_indices ต้องเป็น แบบ 1 มิติ โดยมีขนาดมิติเท่ากับจำนวนมิติของ operand

DynamicSlice(operand, start_indices, slice_sizes)

ดัชนีสไลซ์ที่มีผลจะคำนวณโดยใช้การแปลงต่อไปนี้ สำหรับดัชนีแต่ละรายการ i ใน [1, N) ก่อนที่จะทำการสไลซ์

start_indices[i] = clamp(start_indices[i], 0, operand.dimension_size[i] - slice_sizes[i])

ซึ่งช่วยให้มั่นใจได้ว่า Slice ที่ดึงออกมาจะอยู่ในขอบเขตของอาร์เรย์ตัวถูกดำเนินการเสมอ หากชิ้นอยู่ในขอบเขตก่อนที่จะใช้การเปลี่ยนรูป การเปลี่ยนรูปจะไม่มีผล

ตัวอย่าง 1 มิติ

let a = {0.0, 1.0, 2.0, 3.0, 4.0};
let s = {2};

DynamicSlice(a, s, {2});
// Result: {2.0, 3.0}

ตัวอย่าง 2 มิติ

let b =
{ {0.0,  1.0,  2.0},
  {3.0,  4.0,  5.0},
  {6.0,  7.0,  8.0},
  {9.0, 10.0, 11.0} }
let s = {2, 1}

DynamicSlice(b, s, {2, 2});
//Result:
// { { 7.0,  8.0},
//   {10.0, 11.0} }

ดูข้อมูล StableHLO ได้ที่ StableHLO - dynamic_slice

DynamicUpdateSlice

ดูเพิ่มเติม XlaBuilder::DynamicUpdateSlice

DynamicUpdateSlice จะสร้างผลลัพธ์ซึ่งเป็นค่าของอาร์เรย์อินพุต operand โดยจะเขียนทับสไลซ์ update ที่ start_indices รูปร่างของ update จะกำหนดรูปร่างของอาร์เรย์ย่อยของผลลัพธ์ที่จะอัปเดต รูปร่างของ start_indices ต้องเป็นแบบ 1 มิติ โดยมีขนาดมิติเท่ากับ จำนวนมิติของ operand

DynamicUpdateSlice(operand, update, start_indices)

ดัชนีสไลซ์ที่มีผลจะคำนวณโดยใช้การแปลงต่อไปนี้ สำหรับดัชนีแต่ละรายการ i ใน [1, N) ก่อนที่จะทำการสไลซ์

start_indices[i] = clamp(start_indices[i], 0, operand.dimension_size[i] - update.dimension_size[i])

ซึ่งจะช่วยให้มั่นใจว่า Slice ที่อัปเดตแล้วจะอยู่ในขอบเขตของอาร์เรย์ตัวถูกดำเนินการเสมอ หากชิ้นอยู่ในขอบเขตก่อนที่จะใช้การเปลี่ยนรูป การเปลี่ยนรูปจะไม่มีผล

ตัวอย่าง 1 มิติ

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
let u = {5.0, 6.0}
let s = {2}

DynamicUpdateSlice(a, u, s)
// Result: {0.0, 1.0, 5.0, 6.0, 4.0}

ตัวอย่าง 2 มิติ

let b =
{ {0.0,  1.0,  2.0},
  {3.0,  4.0,  5.0},
  {6.0,  7.0,  8.0},
  {9.0, 10.0, 11.0} }
let u =
{ {12.0, 13.0},
  {14.0, 15.0},
  {16.0, 17.0} }

let s = {1, 1}

DynamicUpdateSlice(b, u, s)
// Result:
// { {0.0,  1.0,  2.0},
//   {3.0, 12.0, 13.0},
//   {6.0, 14.0, 15.0},
//   {9.0, 16.0, 17.0} }

ดูข้อมูล StableHLO ได้ที่ StableHLO - dynamic_update_slice

Erf

ดูเพิ่มเติม XlaBuilder::Erf

ฟังก์ชันข้อผิดพลาดแบบทีละองค์ประกอบ x -> erf(x) โดยที่

\(\text{erf}(x) = \frac{2}{\sqrt{\pi} }\int_0^x e^{-t^2} \, dt\)

Erf(operand)

นอกจากนี้ Erf ยังรองรับอาร์กิวเมนต์ result_accuracy ที่ไม่บังคับด้วย

Erf(operand, result_accuracy)

ดูข้อมูลเพิ่มเติมเกี่ยวกับ result_accuracy ได้ที่ ความถูกต้องของผลลัพธ์

วันหมดอายุ

ดูเพิ่มเติม XlaBuilder::Exp

เลขชี้กำลังธรรมชาติขององค์ประกอบ x -> e^x

Exp(operand)

นอกจากนี้ Exp ยังรองรับอาร์กิวเมนต์ result_accuracy ที่ไม่บังคับด้วย

Exp(operand, result_accuracy)

ดูข้อมูลเพิ่มเติมเกี่ยวกับ result_accuracy ได้ที่ ความถูกต้องของผลลัพธ์

ดูข้อมูล StableHLO ได้ที่ StableHLO - exponential

Expm1

ดูเพิ่มเติม XlaBuilder::Expm1

เลขชี้กำลังธรรมชาติแบบทีละองค์ประกอบลบด้วย 1 x -> e^x - 1

Expm1(operand)

นอกจากนี้ Expm1 ยังรองรับอาร์กิวเมนต์ result_accuracy ที่ไม่บังคับด้วย

Expm1(operand, result_accuracy)

ดูข้อมูลเพิ่มเติมเกี่ยวกับ result_accuracy ได้ที่ ความถูกต้องของผลลัพธ์

ดูข้อมูล StableHLO ได้ที่ StableHLO - exponential_minus_one

Fft

ดูเพิ่มเติม XlaBuilder::Fft

การดำเนินการ FFT ของ XLA จะใช้การแปลงฟูริเยร์ไปข้างหน้าและย้อนกลับสำหรับอินพุต/เอาต์พุตจริงและเชิงซ้อน รองรับ FFT แบบหลายมิติบนแกนสูงสุด 3 แกน

Fft(operand, ftt_type, fft_length)

ดูข้อมูล StableHLO ได้ที่ StableHLO - fft

FFT แบบหลายมิติ

เมื่อระบุ fft_length มากกว่า 1 รายการ การดำเนินการนี้จะเทียบเท่ากับการใช้ การดำเนินการ FFT แบบเรียงซ้อนกับแต่ละแกนด้านในสุด โปรดทราบว่าสำหรับกรณีจริง -> เชิงซ้อนและเชิงซ้อน -> จริง การแปลงแกนในสุดจะดำเนินการก่อน (RFFT; สุดท้ายสำหรับ IRFFT) ซึ่งเป็นเหตุผลที่แกนในสุดเป็นแกนที่มีการเปลี่ยนแปลงขนาด จากนั้นการแปลงแกนอื่นๆ จะเป็น complex->complex

รายละเอียดการใช้งาน

FFT ของ CPU ขับเคลื่อนโดย TensorFFT ของ Eigen FFT ของ GPU ใช้ cuFFT

ชั้น

ดูเพิ่มเติม XlaBuilder::Floor

ฟังก์ชัน Floor แบบองค์ประกอบต่อองค์ประกอบ x -> ⌊x⌋

Floor(operand)

ดูข้อมูล StableHLO ได้ที่ StableHLO - floor

ฟิวชั่น

ดูเพิ่มเติม HloInstruction::CreateFusion

Fusion operation แสดงถึงคำสั่ง HLO และทำหน้าที่เป็น Primitive ใน HLO Op นี้อาจปรากฏในข้อมูลการทิ้ง HLO แต่ไม่ได้มีไว้ให้ผู้ใช้ปลายทางสร้างขึ้นด้วยตนเอง

รวบรวม

การดำเนินการรวบรวม XLA จะรวมชิ้นหลายๆ ชิ้น (แต่ละชิ้นอาจมีออฟเซ็ตเวลาเรียกใช้ที่แตกต่างกัน) ของอาร์เรย์อินพุตเข้าด้วยกัน

ดูข้อมูล StableHLO ได้ที่ StableHLO - gather

ความหมายทั่วไป

ดูเพิ่มเติม XlaBuilder::Gather ดูคำอธิบายที่เข้าใจง่ายขึ้นได้ที่ส่วน "คำอธิบายอย่างไม่เป็นทางการ" ด้านล่าง

gather(operand, start_indices, dimension_numbers, slice_sizes, indices_are_sorted)

เพื่อความสะดวก เราจะติดป้ายกำกับมิติข้อมูลในอาร์เรย์เอาต์พุตที่ไม่ได้อยู่ใน offset_dims เป็น batch_dims

เอาต์พุตคืออาร์เรย์ที่มีมิติข้อมูล batch_dims.size + offset_dims.size

operand.rank ต้องเท่ากับผลรวมของ offset_dims.size และ collapsed_slice_dims.size นอกจากนี้ slice_sizes.size ต้องเท่ากับ operand.rank

หาก index_vector_dim เท่ากับ start_indices.rank เราจะถือว่า start_indices มีมิติข้อมูลต่อท้าย 1 โดยปริยาย (กล่าวคือ หาก start_indices มีรูปร่าง [6,7] และ index_vector_dim เป็น 2 เราจะถือว่ารูปร่างของ start_indices เป็น [6,7,1] โดยปริยาย)

ขอบเขตของอาร์เรย์เอาต์พุตตามมิติข้อมูล i จะคำนวณดังนี้

1. หาก i อยู่ใน batch_dims (เช่น เท่ากับ batch_dims[k] สำหรับบาง k) เราจะเลือกขอบเขตมิติข้อมูลที่สอดคล้องกันจาก start_indices.shape โดยข้าม index_vector_dim (เช่น เลือก start_indices.shape.dims[k] หาก k < index_vector_dim และ start_indices.shape.dims[k+1] ในกรณีอื่นๆ)

2. หาก i อยู่ใน offset_dims (เช่น เท่ากับ offset_dims[k] สำหรับ k บางรายการ) เราจะเลือกขอบเขตที่สอดคล้องกันจาก slice_sizes หลังจาก พิจารณา collapsed_slice_dims แล้ว (เช่น เราจะเลือก adjusted_slice_sizes[k] โดยที่ adjusted_slice_sizes คือ slice_sizes ที่มีการนำขอบเขตที่ดัชนี collapsed_slice_dims ออก)

ในรูปแบบทางการ ดัชนีตัวถูกดำเนินการ In ที่สอดคล้องกับดัชนีเอาต์พุตที่กำหนด Out จะคำนวณได้ดังนี้

1. กำหนดให้ G = { Out[k] สำหรับ k ใน batch_dims } ใช้ G เพื่อแบ่งเวกเตอร์ S ออกเป็นส่วนๆ โดยที่ S[i] = start_indices[Combine(G, i)] โดยที่ Combine(A, b) จะแทรก b ที่ตำแหน่ง index_vector_dim ลงใน A โปรดทราบว่า มีการกำหนดไว้อย่างชัดเจนแม้ว่า G จะว่างเปล่าก็ตาม กล่าวคือ หาก G ว่างเปล่า S จะเท่ากับ start_indices

2. สร้างดัชนีเริ่มต้น Sin ใน operand โดยใช้ S โดย กระจาย S โดยใช้ start_index_map โดยมีรายละเอียดดังนี้

   1. Sin[start_index_map[k]] = S[k] if k < start_index_map.size.

   2. Sin[_] = 0 มิฉะนั้น

3. สร้างดัชนี Oin ลงใน operand โดยกระจายดัชนี ที่มิติข้อมูลออฟเซ็ตใน Out ตามชุด collapsed_slice_dims โดยมีรายละเอียดดังนี้

   1. Oin[remapped_offset_dims(k)] = Out[offset_dims[k]] if k < offset_dims.size (remapped_offset_dims is defined below).

   2. Oin[_] = 0 มิฉะนั้น

4. In คือ Oin + Sin โดยที่ + คือการบวกแบบทีละองค์ประกอบ

remapped_offset_dims เป็นฟังก์ชันโมโนโทนิกที่มีโดเมน [0, offset_dims.size) และช่วง [0, operand.rank) \ collapsed_slice_dims ดังนั้น หาก offset_dims.size คือ 4, operand.rank คือ 6 และ collapsed_slice_dims คือ {0, 2} ดังนั้น remapped_offset_dims คือ {0→1, 1→3, 2→4, 3→5}

หากตั้งค่า indices_are_sorted เป็น "จริง" XLA จะถือว่าผู้ใช้ได้จัดเรียง start_indices แล้ว (เรียงจากน้อยไปมาก หลังจากกระจายค่าตาม start_index_map) หากไม่เป็นเช่นนั้น ความหมายจะเป็น การใช้งานที่กำหนด

คำอธิบายและตัวอย่างอย่างไม่เป็นทางการ

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

• เราใช้มิติข้อมูลกลุ่มใน Out เพื่อค้นหาดัชนีเริ่มต้นจาก start_indices

• เราใช้ start_index_map เพื่อแมปดัชนีเริ่มต้น (ซึ่งอาจมีขนาดน้อยกว่า operand.rank) กับดัชนีเริ่มต้น "เต็ม" ใน operand

• เราจะแบ่งส่วนแบบไดนามิกโดยใช้ขนาด slice_sizes โดยใช้ดัชนีเริ่มต้นแบบเต็ม

• เราปรับรูปร่างสไลซ์โดยการยุบcollapsed_slice_dimsมิติข้อมูล เนื่องจากมิติข้อมูลสไลซ์ที่ยุบทั้งหมดต้องมีขอบเขตเป็น 1 การเปลี่ยนรูปร่างนี้จึง ถูกต้องเสมอ

• เราใช้มิติข้อมูลออฟเซ็ตใน Out เพื่อจัดทำดัชนีในชิ้นนี้เพื่อรับองค์ประกอบอินพุต E ที่สอดคล้องกับดัชนีเอาต์พุต Out

index_vector_dim ตั้งค่าเป็น start_indices.rank - 1 ในตัวอย่างทั้งหมด ที่ตามมา ค่าที่น่าสนใจมากขึ้นสำหรับ index_vector_dim do not change the operation fundamentally แต่ทำให้การแสดงภาพยุ่งยากมากขึ้น

หากต้องการดูว่าองค์ประกอบทั้งหมดข้างต้นทำงานร่วมกันอย่างไร ลองดูตัวอย่างที่รวบรวมชิ้นส่วน 5 ชิ้นที่มีรูปร่าง [8,6] จากอาร์เรย์ [16,11] [16,11] อาร์เรย์สามารถแสดงตำแหน่งของสไลซ์เป็นเวกเตอร์ดัชนีที่มีรูปร่าง S64[2] ดังนั้นชุดตำแหน่ง 5 ตำแหน่งจึงแสดงเป็นอาร์เรย์ S64[5,2] ได้

จากนั้นลักษณะการทำงานของการดำเนินการรวบรวมจะแสดงเป็นการเปลี่ยนดัชนี ที่ใช้ [G,O0,O1] ซึ่งเป็นดัชนีใน รูปร่างเอาต์พุต และแมปกับองค์ประกอบในอาร์เรย์อินพุตในลักษณะต่อไปนี้

ก่อนอื่นเราจะเลือกเวกเตอร์ (X,Y) จากอาร์เรย์ดัชนีรวบรวมโดยใช้ G จากนั้น องค์ประกอบในอาร์เรย์เอาต์พุตที่ดัชนี [G,O0,O1] จะเป็นองค์ประกอบในอาร์เรย์อินพุต ที่ดัชนี [X+O0,Y+O1]

slice_sizes คือ [8,6] ซึ่งกำหนดช่วงของ O₀ และ O₁ และสิ่งนี้จะกำหนดขอบเขตของสไลซ์

การดำเนินการรวบรวมนี้ทำหน้าที่เป็น Slice แบบไดนามิกของกลุ่มที่มี G เป็นมิติข้อมูลกลุ่ม

ดัชนีการรวบรวมอาจเป็นแบบหลายมิติ เช่น เวอร์ชันทั่วไปของตัวอย่างด้านบนที่ใช้อาร์เรย์ "รวบรวมดัชนี" ที่มีรูปร่าง [4,5,2] จะแปลดัชนีดังนี้

อีกครั้งที่นี่จะทำหน้าที่เป็นกลุ่มสไลซ์แบบไดนามิก G0 และ G1 เป็นมิติข้อมูลกลุ่ม ขนาดของชิ้นยังคงเป็น [8,6]

การดำเนินการรวบรวมใน XLA จะสรุปความหมายที่ไม่เป็นทางการที่ระบุไว้ข้างต้นในลักษณะต่อไปนี้

1. เราสามารถกำหนดค่ามิติข้อมูลใดในรูปร่างเอาต์พุตเป็นมิติข้อมูลออฟเซ็ต ได้ (มิติข้อมูลที่มี O0, O1 ใน ตัวอย่างสุดท้าย) มิติข้อมูลกลุ่มเอาต์พุต (มิติข้อมูลที่มี G0, G1 ในตัวอย่างล่าสุด) จะกำหนดให้เป็นมิติข้อมูลเอาต์พุตที่ไม่ใช่มิติข้อมูลออฟเซ็ต

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

3. ชิ้นที่ดึงมาจากอาร์เรย์ "รวบรวมดัชนี" ((X, Y) ในตัวอย่างสุดท้าย ) อาจมีองค์ประกอบน้อยกว่าจำนวนมิติข้อมูลของอาร์เรย์อินพุต และการแมปที่ชัดเจนจะกำหนดวิธีขยายดัชนีเพื่อให้มีจำนวนมิติข้อมูลเท่ากับอินพุต

ตัวอย่างสุดท้าย เราใช้ (2) และ (3) เพื่อใช้ tf.gather_nd ดังนี้

G0 และ G1 ใช้เพื่อแบ่งดัชนีเริ่มต้นออกจากอาร์เรย์ดัชนีรวบรวมตามปกติ ยกเว้นดัชนีเริ่มต้นจะมีองค์ประกอบเพียงรายการเดียวคือ X ในทำนองเดียวกัน จะมีดัชนีออฟเซ็ตเอาต์พุตเพียงรายการเดียวที่มีค่า O0 อย่างไรก็ตาม ก่อนที่จะใช้เป็นดัชนีในอาร์เรย์อินพุต ระบบจะขยายดัชนีเหล่านี้ตาม "การแมปดัชนี Gather" (start_index_map ใน คำอธิบายอย่างเป็นทางการ) และ "การแมปออฟเซ็ต" (remapped_offset_dims ใน คำอธิบายอย่างเป็นทางการ) เป็น [X,0] และ [0,O0] ตามลำดับ รวมเป็น [X,O0] กล่าวอีกนัยหนึ่งคือ ดัชนีเอาต์พุต [G0,G1,O0] จะแมปกับดัชนีอินพุต [GatherIndices[G0,G1,0],O0] ซึ่งจะให้ความหมายสำหรับ tf.gather_nd

slice_sizes สำหรับเคสนี้คือ [1,11] โดยสัญชาตญาณแล้ว หมายความว่าดัชนี X ทุกตัวในอาร์เรย์ดัชนีการรวบรวมจะเลือกทั้งแถว และผลลัพธ์คือการ ต่อกันของแถวทั้งหมดนี้

GetDimensionSize

ดูเพิ่มเติม XlaBuilder::GetDimensionSize

แสดงผลขนาดของมิติข้อมูลที่ระบุของตัวถูกดำเนินการ ตัวถูกดำเนินการต้องมีรูปร่างเป็นอาร์เรย์

GetDimensionSize(operand, dimension)

ดูข้อมูล StableHLO ได้ที่ StableHLO - get_dimension_size

GetTupleElement

ดูเพิ่มเติม XlaBuilder::GetTupleElement

ดัชนีลงในทูเพิลที่มีค่าคงที่ในเวลาคอมไพล์

ค่าต้องเป็นค่าคงที่ในเวลาคอมไพล์เพื่อให้การอนุมานรูปร่างกำหนดประเภทของค่าผลลัพธ์ได้

ซึ่งคล้ายกับ std::get<int N>(t) ใน C++ โดยในเชิงแนวคิดแล้ว

let v: f32[10] = f32[10]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
let s: s32 = 5;
let t: (f32[10], s32) = tuple(v, s);
let element_1: s32 = gettupleelement(t, 1); // Inferred shape matches s32.

ดู tf.tuple เพิ่มเติม

GetTupleElement(tuple_data, index)

ดูข้อมูล StableHLO ได้ที่ StableHLO - get_tuple_element

Imag

ดูเพิ่มเติม XlaBuilder::Imag

ส่วนจินตภาพของรูปร่างเชิงซ้อน (หรือจริง) แบบทีละองค์ประกอบ x -> imag(x) หาก ตัวถูกดำเนินการเป็นประเภททศนิยม จะแสดงผล 0

Imag(operand)

ดูข้อมูล StableHLO ได้ที่ StableHLO - imag

ในฟีด

ดูเพิ่มเติม XlaBuilder::Infeed

Infeed(shape, config)

อ่านรายการข้อมูลรายการเดียวจากอินเทอร์เฟซการสตรีมในฟีดโดยนัยของ อุปกรณ์ โดยตีความข้อมูลเป็นรูปร่างและเลย์เอาต์ที่กำหนด และส่งคืน XlaOpของข้อมูล อนุญาตให้มีการดำเนินการ Infeed หลายรายการในการคำนวณ แต่ต้องมีการเรียงลำดับการดำเนินการ Infeed ทั้งหมด ตัวอย่างเช่น 2 Infeed ในโค้ดด้านล่างมีลำดับรวมเนื่องจากมีการขึ้นต่อกัน ระหว่างลูป while

result1 = while (condition, init = init_value) {
  Infeed(shape)
  }

result2 = while (condition, init = result1) {
  Infeed(shape)
  }

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

ดูข้อมูล StableHLO ได้ที่ StableHLO - ในฟีด

Iota

ดูเพิ่มเติม XlaBuilder::Iota

Iota(shape, iota_dimension)

สร้างค่าคงที่แบบอักษรบนอุปกรณ์แทนการโอนข้อมูลที่อาจมีขนาดใหญ่ไปยังโฮสต์ สร้างอาร์เรย์ที่มีรูปร่างที่ระบุและมีค่าเริ่มต้นที่ 0 และเพิ่มขึ้นทีละ 1 ตามมิติข้อมูลที่ระบุ สำหรับประเภททศนิยม อาร์เรย์ที่สร้างขึ้นจะเทียบเท่ากับ ConvertElementType(Iota(...)) โดยที่ Iota เป็นประเภทจำนวนเต็มและการแปลงเป็นประเภททศนิยม

เช่น Iota(s32[4, 8], 0) จะแสดงผล

[[0, 0, 0, 0, 0, 0, 0, 0 ],
 [1, 1, 1, 1, 1, 1, 1, 1 ],
 [2, 2, 2, 2, 2, 2, 2, 2 ],
 [3, 3, 3, 3, 3, 3, 3, 3 ]]

ส่งคืนสินค้า Iota(s32[4, 8], 1)

[[0, 1, 2, 3, 4, 5, 6, 7 ],
 [0, 1, 2, 3, 4, 5, 6, 7 ],
 [0, 1, 2, 3, 4, 5, 6, 7 ],
 [0, 1, 2, 3, 4, 5, 6, 7 ]]

ดูข้อมูล StableHLO ได้ที่ StableHLO - iota

IsFinite

ดูเพิ่มเติม XlaBuilder::IsFinite

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

IsFinite(operand)

ดูข้อมูล StableHLO ได้ที่ StableHLO - is_finite

บันทึก

ดูเพิ่มเติม XlaBuilder::Log

ลอการิทึมธรรมชาติแบบองค์ประกอบต่อองค์ประกอบ x -> ln(x)

Log(operand)

นอกจากนี้ ฟังก์ชันบันทึกยังรองรับอาร์กิวเมนต์ result_accuracy ที่ไม่บังคับด้วย

Log(operand, result_accuracy)

ดูข้อมูลเพิ่มเติมเกี่ยวกับ result_accuracy ได้ที่ ความถูกต้องของผลลัพธ์

ดูข้อมูล StableHLO ได้ที่ StableHLO - log

Log1p

ดูเพิ่มเติม XlaBuilder::Log1p

ลอการิทึมธรรมชาติที่เลื่อนทีละองค์ประกอบ x -> ln(1+x)

Log1p(operand)

นอกจากนี้ Log1p ยังรองรับอาร์กิวเมนต์ result_accuracy ที่ไม่บังคับด้วย

Log1p(operand, result_accuracy)

ดูข้อมูลเพิ่มเติมเกี่ยวกับ result_accuracy ได้ที่ ความถูกต้องของผลลัพธ์

ดูข้อมูล StableHLO ได้ที่ StableHLO - log_plus_one

Logistic

ดูเพิ่มเติม XlaBuilder::Logistic

การคำนวณฟังก์ชันโลจิสติกแบบทีละองค์ประกอบ x -> logistic(x)

Logistic(operand)

นอกจากนี้ ฟังก์ชัน LOG ยังรองรับอาร์กิวเมนต์ result_accuracy ที่ไม่บังคับด้วย

Logistic(operand, result_accuracy)

ดูข้อมูลเพิ่มเติมเกี่ยวกับ result_accuracy ได้ที่ ความถูกต้องของผลลัพธ์

ดูข้อมูล StableHLO ได้ที่ StableHLO - logistic

แผนที่

ดูเพิ่มเติม XlaBuilder::Map

Map(operands..., computation, dimensions)

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

ฟังก์ชันที่แมปคือการคำนวณโดยพลการที่มีข้อจำกัดว่าต้องมีอินพุต N รายการประเภทสเกลาร์ T และเอาต์พุตรายการเดียวที่มีประเภท S เอาต์พุตมี มิติข้อมูลเดียวกับตัวถูกดำเนินการ ยกเว้นว่าประเภทองค์ประกอบ T จะถูกแทนที่ ด้วย S

เช่น Map(op1, op2, op3, computation, par1) จะแมป elem_out <- computation(elem1, elem2, elem3, par1) ที่ดัชนี (หลายมิติ) แต่ละรายการใน อาร์เรย์อินพุตเพื่อสร้างอาร์เรย์เอาต์พุต

ดูข้อมูล StableHLO ได้ที่ StableHLO - map

สูงสุด

ดูเพิ่มเติม XlaBuilder::Max

ดำเนินการหาค่าสูงสุดแบบทีละองค์ประกอบในเทนเซอร์ lhs และ rhs

Max(lhs, rhs)

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

Max มีตัวเลือกอื่นที่รองรับการออกอากาศแบบหลายมิติ ดังนี้

Max(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - maximum

ต่ำสุด

ดูเพิ่มเติม XlaBuilder::Min

ดำเนินการ min แบบทีละองค์ประกอบใน lhs และ rhs

Min(lhs, rhs)

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

มีตัวเลือกอื่นที่รองรับการออกอากาศแบบหลายมิติ สำหรับ Min ดังนี้

Min(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - ขั้นต่ำ

Mul

ดูเพิ่มเติม XlaBuilder::Mul

ดำเนินการคูณแบบทีละองค์ประกอบของ lhs และ rhs

Mul(lhs, rhs)

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

Mul มีตัวเลือกอื่นที่รองรับการออกอากาศแบบหลายมิติ ดังนี้

Mul(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - multiply

Neg

ดูเพิ่มเติม XlaBuilder::Neg

การนิเสธแบบทีละองค์ประกอบ x -> -x

Neg(operand)

ดูข้อมูล StableHLO ได้ที่ StableHLO - negate

ไม่ใช่

ดูเพิ่มเติม XlaBuilder::Not

ตัวดำเนินการนิเสธเชิงตรรกะแบบทีละองค์ประกอบ x -> !(x)

Not(operand)

ดูข้อมูล StableHLO ได้ที่ StableHLO - not

OptimizationBarrier

ดูเพิ่มเติม XlaBuilder::OptimizationBarrier

บล็อกการเพิ่มประสิทธิภาพไม่ให้ย้ายการคำนวณข้ามขอบเขต

OptimizationBarrier(operand)

ตรวจสอบว่ามีการประเมินอินพุตทั้งหมดก่อนตัวดำเนินการที่ขึ้นอยู่กับเอาต์พุตของ Barrier

ดูข้อมูล StableHLO ได้ที่ StableHLO - optimization_barrier

หรือ

ดูเพิ่มเติม XlaBuilder::Or

ดำเนินการ OR แบบทีละองค์ประกอบของ lhs และ rhs

Or(lhs, rhs)

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

Or มีตัวแปรอื่นที่รองรับการออกอากาศแบบหลายมิติ สำหรับ Or

Or(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - หรือ

ฟีดขาออก

ดูเพิ่มเติม XlaBuilder::Outfeed

เขียนอินพุตไปยังเอาต์ฟีด

Outfeed(operand, shape_with_layout, outfeed_config)

shape_with_layout สื่อถึงรูปร่างที่วางไว้ซึ่งเราต้องการแสดง

ดูข้อมูล StableHLO ได้ที่ StableHLO - outfeed

แผ่นรอง

ดูเพิ่มเติม XlaBuilder::Pad

Pad(operand, padding_value, padding_config)

ขยายอาร์เรย์ operand ที่ระบุโดยการเพิ่มระยะขอบรอบอาร์เรย์และระหว่างองค์ประกอบของอาร์เรย์ด้วย padding_value ที่ระบุ padding_config ระบุจำนวนการเว้นขอบและการเว้นภายในสำหรับแต่ละ มิติข้อมูล

PaddingConfig เป็นฟิลด์ที่ซ้ำของ PaddingConfigDimension ซึ่งมีฟิลด์ 3 รายการสำหรับแต่ละมิติข้อมูล ได้แก่ edge_padding_low, edge_padding_high และ interior_padding

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

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

การดำเนินการนี้จะไม่มีผลหากคู่การป้อนขอบทั้งหมดเป็น (0, 0) และค่าการป้อนภายในทั้งหมดเป็น 0 รูปภาพด้านล่างแสดงตัวอย่างค่าedge_paddingและinterior_paddingต่างๆ สำหรับอาร์เรย์ 2 มิติ

ดูข้อมูล StableHLO ได้ที่ StableHLO - pad

พารามิเตอร์

ดูเพิ่มเติม XlaBuilder::Parameter

Parameter แสดงถึงอินพุตอาร์กิวเมนต์ในการคำนวณ

PartitionID

ดูเพิ่มเติม XlaBuilder::BuildPartitionId

สร้าง partition_id ของกระบวนการปัจจุบัน

PartitionID(shape)

PartitionID อาจปรากฏในข้อมูลการทิ้ง HLO แต่ไม่ได้มีไว้ให้ผู้ใช้ปลายทางสร้างขึ้นด้วยตนเอง

ดูข้อมูล StableHLO ได้ที่ StableHLO - partition_id

PopulationCount

ดูเพิ่มเติม XlaBuilder::PopulationCount

คำนวณจำนวนบิตที่ตั้งค่าในแต่ละองค์ประกอบของ operand

PopulationCount(operand)

ดูข้อมูล StableHLO ได้ที่ StableHLO - popcnt

Pow

ดูเพิ่มเติม XlaBuilder::Pow

ดำเนินการยกกำลังแบบทีละองค์ประกอบของ lhs ด้วย rhs

Pow(lhs, rhs)

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

Pow มีตัวเลือกอื่นที่รองรับการออกอากาศแบบหลายมิติ

Pow(lhs,rhs, broadcast_dimensions)

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

ตัวถูกดำเนินการ broadcast_dimensions เพิ่มเติมคือ Slice ของจำนวนเต็มที่ระบุ มิติข้อมูลที่จะใช้สำหรับการออกอากาศตัวถูกดำเนินการ ดูรายละเอียดความหมายได้ในหน้าการออกอากาศ

ดูข้อมูล StableHLO ได้ที่ StableHLO - power

จริง

ดูเพิ่มเติม XlaBuilder::Real

ส่วนจริงของรูปร่างเชิงซ้อน (หรือจริง) แบบทีละองค์ประกอบ x -> real(x) หากตัวถูกดำเนินการเป็นประเภททศนิยม Real จะแสดงผลค่าเดียวกัน

Real(operand)

ดูข้อมูล StableHLO ได้ที่ StableHLO - real

Recv

ดูเพิ่มเติม XlaBuilder::Recv

Recv, RecvWithTokens และ RecvToHost เป็นการดำเนินการที่ทำหน้าที่เป็น องค์ประกอบพื้นฐานของการสื่อสารใน HLO โดยปกติแล้วการดำเนินการเหล่านี้จะปรากฏในการดัมพ์ HLO เป็นส่วนหนึ่ง ของการรับ/ส่งข้อมูลระดับต่ำหรือการโอนข้ามอุปกรณ์ แต่ไม่ได้มีไว้ ให้ผู้ใช้ปลายทางสร้างขึ้นด้วยตนเอง

Recv(shape, handle)

รับข้อมูลที่มีรูปร่างที่กำหนดจากคำสั่ง Send ในการคำนวณอื่น ที่ใช้แฮนเดิลช่องเดียวกัน แสดงผล XlaOp สำหรับข้อมูลที่ได้รับ

ดูข้อมูล StableHLO ได้ที่ StableHLO - recv

RecvDone

ดูเพิ่มเติม HloInstruction::CreateRecv และ HloInstruction::CreateRecvDone

เช่นเดียวกับ Send, API ไคลเอ็นต์ของการดำเนินการ Recv แสดงถึง การสื่อสารแบบซิงโครนัส อย่างไรก็ตาม คำสั่งจะแยกย่อยภายใน เป็นคำสั่ง HLO 2 รายการ (Recv และ RecvDone) เพื่อเปิดใช้การโอนข้อมูลแบบอะซิงโครนัส

Recv(const Shape& shape, int64 channel_id)

จัดสรรทรัพยากรที่จำเป็นเพื่อรับข้อมูลจากคำสั่ง Send ที่มี channel_id เดียวกัน แสดงบริบทสำหรับทรัพยากรที่จัดสรร ซึ่งRecvDone คำสั่งต่อไปนี้ใช้เพื่อรอให้การโอนข้อมูลเสร็จสมบูรณ์ บริบทคือทูเพิลของ {บัฟเฟอร์รับ (รูปร่าง), ตัวระบุคำขอ (U32)} และใช้ได้เฉพาะคำสั่ง RecvDone เท่านั้น

เมื่อได้รับบริบทที่สร้างขึ้นจากคำสั่ง Recv ฟังก์ชันนี้จะรอให้การโอนข้อมูลเสร็จสมบูรณ์และส่งคืนข้อมูลที่ได้รับ

ลด (Reduce)

ดูเพิ่มเติม XlaBuilder::Reduce

ใช้ฟังก์ชันการลดกับอาร์เรย์อย่างน้อย 1 รายการแบบขนาน

Reduce(operands..., init_values..., computation, dimensions_to_reduce)

สถานที่:

• N ต้องมากกว่าหรือเท่ากับ 1
• การคำนวณต้องเป็นแบบเชื่อมโยง "โดยประมาณ" (ดูด้านล่าง)
• อาร์เรย์อินพุตทั้งหมดต้องมีมิติข้อมูลเดียวกัน
• ค่าเริ่มต้นทั้งหมดต้องสร้างเอกลักษณ์ภายใต้ computation
• หาก N = 1 Collate(T) จะเป็น T
• หาก N > 1, Collate(T_0, ..., T_{N-1}) เป็นทูเพิลขององค์ประกอบ N ประเภท T

การดำเนินการนี้จะลดมิติข้อมูลอย่างน้อย 1 รายการของอาร์เรย์อินพุตแต่ละรายการให้เป็นสเกลาร์ จำนวนมิติข้อมูลของอาร์เรย์ที่แสดงผลแต่ละรายการคือ number_of_dimensions(operand) - len(dimensions) เอาต์พุตของ Op คือ Collate(Q_0, ..., Q_N) โดยที่ Q_i เป็นอาร์เรย์ประเภท T_i ซึ่งมี มิติข้อมูลตามที่อธิบายไว้ด้านล่าง

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

ดูข้อมูล StableHLO ได้ที่ StableHLO - reduce

ตัวอย่าง

เมื่อลดตามมิติเดียวในอาร์เรย์ 1 มิติเดียวที่มีค่า [10, 11, 12, 13] โดยมีฟังก์ชันการลด f (ซึ่งก็คือ computation) ระบบจะคำนวณได้ดังนี้

f(10, f(11, f(12, f(init_value, 13)))

แต่ก็ยังมีอีกหลายกรณีที่เป็นไปได้ เช่น

f(init_value, f(f(10, f(init_value, 11)), f(f(init_value, 12), f(init_value, 13))))

ต่อไปนี้คือตัวอย่างรหัสเทียมคร่าวๆ ของวิธี การใช้การลด โดยใช้การบวกเป็นค่าเริ่มต้น ของการคำนวณการลดเป็น 0

result_shape <- remove all dims in dimensions from operand_shape

# Iterate over all elements in result_shape. The number of r's here is equal
# to the number of dimensions of the result.
for r0 in range(result_shape[0]), r1 in range(result_shape[1]), ...:
  # Initialize this result element
  result[r0, r1...] <- 0

  # Iterate over all the reduction dimensions
  for d0 in range(dimensions[0]), d1 in range(dimensions[1]), ...:
    # Increment the result element with the value of the operand's element.
    # The index of the operand's element is constructed from all ri's and di's
    # in the right order (by construction ri's and di's together index over the
    # whole operand shape).
    result[r0, r1...] += operand[ri... di]

ต่อไปนี้เป็นตัวอย่างการลดอาร์เรย์ 2 มิติ (เมทริกซ์) รูปร่างมี 2 มิติ มิติที่ 0 มีขนาด 2 และมิติที่ 1 มีขนาด 3 ดังนี้

ผลลัพธ์ของการลดมิติข้อมูล 0 หรือ 1 ด้วยฟังก์ชัน "add"

โปรดทราบว่าผลลัพธ์ของการลดทั้ง 2 แบบคืออาร์เรย์ 1 มิติ แผนภาพแสดงรายการหนึ่งเป็นคอลัมน์ และอีกรายการเป็นแถวเพื่อความสะดวกในการมองเห็น

หากต้องการดูตัวอย่างที่ซับซ้อนมากขึ้น นี่คืออาร์เรย์ 3 มิติ มีจำนวนมิติข้อมูล 3 มิติ มิติข้อมูล 0 มีขนาด 4 มิติข้อมูล 1 มีขนาด 2 และมิติข้อมูล 2 มีขนาด 3 เพื่อความ ง่าย ค่า 1 ถึง 6 จะทำซ้ำในมิติข้อมูล 0

เช่นเดียวกับตัวอย่าง 2 มิติ เราสามารถลดมิติข้อมูลเพียงมิติเดียวได้ เช่น หากลด มิติข้อมูล 0 เราจะได้อาร์เรย์ 2 มิติที่ค่าทั้งหมดใน มิติข้อมูล 0 ถูกพับเป็นสเกลาร์

|  4   8  12 |
| 16  20  24 |

หากลดมิติข้อมูลที่ 2 เราจะได้อาร์เรย์ 2 มิติซึ่งค่าทั้งหมด ในมิติข้อมูลที่ 2 จะรวมกันเป็นสเกลาร์

| 6  15 |
| 6  15 |
| 6  15 |
| 6  15 |

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

นอกจากนี้ เรายังลดมิติข้อมูลหลายรายการได้ด้วย การเพิ่มมิติข้อมูลที่ลดลง 0 และ 1 จะสร้างอาร์เรย์ 1 มิติ [20, 28, 36]

การลดอาร์เรย์ 3 มิติในทุกมิติจะทำให้เกิดสเกลาร์ 84

Variadic Reduce

เมื่อใช้ N > 1 ฟังก์ชัน Reduce จะมีความซับซ้อนมากขึ้นเล็กน้อย เนื่องจากจะ ใช้กับอินพุตทั้งหมดพร้อมกัน ระบบจะส่งตัวถูกดำเนินการไปยัง การคำนวณตามลำดับต่อไปนี้

• การเรียกใช้ค่าที่ลดลงสำหรับตัวถูกดำเนินการแรก
• ...
• ค่าที่ลดลงของตัวถูกดำเนินการที่ N
• ค่าอินพุตสำหรับตัวถูกดำเนินการแรก
• ...
• ค่าอินพุตสำหรับตัวถูกดำเนินการที่ N

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

f: (Float, Int, Float, Int) -> Float, Int
f(max, argmax, value, index):
  if value >= max:
    return (value, index)
  else:
    return (max, argmax)

สำหรับอาร์เรย์อินพุต 1 มิติ V = Float[N], K = Int[N] และค่าเริ่มต้น I_V = Float, I_K = Int ผลลัพธ์ f_(N-1) ของการลดในมิติข้อมูลอินพุต เพียงมิติเดียวจะเทียบเท่ากับการใช้แบบเรียกซ้ำต่อไปนี้

f_0 = f(I_V, I_K, V_0, K_0)
f_1 = f(f_0.first, f_0.second, V_1, K_1)
...
f_(N-1) = f(f_(N-2).first, f_(N-2).second, V_(N-1), K_(N-1))

การใช้การลดนี้กับอาร์เรย์ของค่าและอาร์เรย์ของดัชนีตามลำดับ (เช่น iota) จะวนซ้ำพร้อมกันในอาร์เรย์ และแสดงผลทูเพิล ที่มีค่าสูงสุดและดัชนีที่ตรงกัน

ReducePrecision

ดูเพิ่มเติม XlaBuilder::ReducePrecision

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

ReducePrecision(operand, exponent_bits, mantissa_bits)

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

รูปแบบที่มีความแม่นยำต่ำกว่าต้องมีบิตเลขชี้กำลังอย่างน้อย 1 บิต (เพื่อแยกค่าศูนย์ออกจากค่าอนันต์ เนื่องจากทั้ง 2 ค่ามีแมนทิสซาเป็นศูนย์) และต้องมีจำนวนบิตแมนทิสซาที่ไม่เป็นลบ จำนวนบิตของเลขชี้กำลังหรือ แมนทิสซาอาจเกินค่าที่สอดคล้องกับประเภท T จากนั้นส่วนที่สอดคล้องกันของ Conversion จะไม่มีการดำเนินการใดๆ

ดูข้อมูล StableHLO ได้ที่ StableHLO - reduce_precision

ReduceScatter

ดูเพิ่มเติม XlaBuilder::ReduceScatter

ReduceScatter เป็นการดำเนินการแบบรวมที่ทำ AllReduce และ จากนั้นกระจายผลลัพธ์โดยการแบ่งออกเป็นshard_count บล็อกตาม scatter_dimension และรีพลิกากลุ่ม i จะได้รับ ith ชาร์ด

ReduceScatter(operand, computation, scatter_dimension, shard_count, replica_groups, channel_id, layout, use_global_device_ids)

• เมื่อ operand เป็นทูเพิลของอาร์เรย์ ระบบจะดำเนินการรีดิวซ์สแคตเตอร์กับแต่ละ องค์ประกอบของทูเพิล
• replica_groups คือรายการกลุ่มจำลองที่จะดำเนินการลด (ดึงข้อมูลรหัสจำลองสำหรับจำลองปัจจุบันได้โดยใช้ ReplicaId) ลำดับของจำลองในแต่ละกลุ่มจะกำหนด ลำดับที่จะกระจายผลลัพธ์การลดทั้งหมด replica_groups ต้องว่างเปล่า (ในกรณีนี้แบบจำลองทั้งหมดจะอยู่ในกลุ่มเดียว) หรือมีจำนวนองค์ประกอบเท่ากับจำนวนแบบจำลอง เมื่อมีกลุ่มรีพลิกามากกว่า 1 กลุ่ม กลุ่มรีพลิกาทั้งหมดจะต้องมีขนาดเท่ากัน เช่น replica_groups = {0, 2}, {1, 3} จะทำการลดระหว่างรีพลิกา 0 กับ 2 และ 1 กับ 3 แล้วกระจายผลลัพธ์
• shard_count คือขนาดของกลุ่มรีพลิกาทุกกลุ่ม เราต้องการข้อมูลนี้ในกรณีที่replica_groupsว่างเปล่า หาก replica_groups ไม่ว่าง shard_count จะต้องเท่ากับขนาดของกลุ่มรีพลิเคชันแต่ละกลุ่ม
• channel_id ใช้สำหรับการสื่อสารข้ามโมดูล โดยมีเพียงreduce-scatter การดำเนินการที่มีchannel_id เดียวกันเท่านั้นที่สื่อสารกันได้
• layout ดูข้อมูลเพิ่มเติมเกี่ยวกับเลย์เอาต์ได้ที่ xla::shapes
• use_global_device_ids คือแฟล็กที่ผู้ใช้ระบุ เมื่อ false(ค่าเริ่มต้น) ตัวเลขใน replica_groups จะเป็น ReplicaId เมื่อ true ตัวเลขใน replica_groups แสดงถึงรหัสส่วนกลางของ (ReplicaID*partition_count + partition_id) เช่น
  • โดยมี 2 สำเนาและ 4 พาร์ติชัน
  • replica_groups={ {0,1,4,5},{2,3,6,7} } and use_global_device_ids=true
  • group[0] = (0,0), (0,1), (1,0), (1,1)
  • group[1] = (0,2), (0,3), (1,2), (1,3)
  • โดยแต่ละคู่คือ (replica_id, partition_id)

รูปร่างเอาต์พุตคือรูปร่างอินพุตที่มีขนาดเล็กลง scatter_dimension shard_count เท่า เช่น หากมี 2 สำเนาและตัวถูกดำเนินการมีค่า [1.0, 2.25] และ [3.0, 5.25] ตามลำดับใน 2 สำเนา ค่าเอาต์พุตจาก Op นี้ที่ scatter_dim คือ 0 จะเป็น [4.0] สำหรับสำเนาแรกและ [7.5] สำหรับสำเนาที่สอง

ดูข้อมูล StableHLO ได้ที่ StableHLO - reduce_scatter

ReduceScatter - ตัวอย่างที่ 1 - StableHLO

ในตัวอย่างข้างต้น มีรีพลิกา 2 รายการที่เข้าร่วมใน ReduceScatter ในแต่ละรีพลิกา โอเปอแรนด์มีรูปร่าง f32[2,4] การลดทั้งหมด (ผลรวม) จะดำเนินการในรีพลิกาทั้งหมด ซึ่งจะสร้างค่าที่ลดลงของรูปร่าง f32[2,4] ในแต่ละรีพลิกา จากนั้นระบบจะแบ่งค่าที่ลดลงนี้ออกเป็น 2 ส่วนตามมิติข้อมูล 1 เพื่อให้แต่ละส่วนมีรูปร่าง f32[2,2] แต่ละรีพลิกาในกลุ่มกระบวนการจะได้รับ ส่วนที่สอดคล้องกับตำแหน่งของรีพลิกาในกลุ่ม ด้วยเหตุนี้ เอาต์พุตใน แต่ละรีพลิก้าจึงมีรูปร่าง f32[2,2]

ReduceWindow

ดูเพิ่มเติม XlaBuilder::ReduceWindow

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

ReduceWindow(operands..., init_values..., computation, window_dimensions, window_strides, padding)

สถานที่:

• N ต้องมากกว่าหรือเท่ากับ 1
• อาร์เรย์อินพุตทั้งหมดต้องมีมิติข้อมูลเดียวกัน
• หาก N = 1 Collate(T) จะเป็น T
• หาก N > 1, Collate(T_0, ..., T_{N-1}) เป็นทูเพิลขององค์ประกอบ N ประเภท (T0,...T{N-1})

ดูข้อมูล StableHLO ได้ที่ StableHLO - reduce_window

ReduceWindow - ตัวอย่าง 1

อินพุตคือเมทริกซ์ขนาด [4x6] และทั้ง window_dimensions และ window_stride_dimensions คือ [2x3]

// Create a computation for the reduction (maximum).
XlaComputation max;
{
  XlaBuilder builder(client_, "max");
  auto y = builder.Parameter(0, ShapeUtil::MakeShape(F32, {}), "y");
  auto x = builder.Parameter(1, ShapeUtil::MakeShape(F32, {}), "x");
  builder.Max(y, x);
  max = builder.Build().value();
}

// Create a ReduceWindow computation with the max reduction computation.
XlaBuilder builder(client_, "reduce_window_2x3");
auto shape = ShapeUtil::MakeShape(F32, {4, 6});
auto input = builder.Parameter(0, shape, "input");
builder.ReduceWindow(
    input,
    /*init_val=*/builder.ConstantLiteral(LiteralUtil::MinValue(F32)),
    *max,
    /*window_dimensions=*/{2, 3},
    /*window_stride_dimensions=*/{2, 3},
    Padding::kValid);