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

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

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

AfterAll

โปรดดูXlaBuilder::AfterAll

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

AfterAll(operands)

AllGather

โปรดดูXlaBuilder::AllGather

ดำเนินการต่อท้ายกันในรีเพลซิคา

AllGather(operand, all_gather_dim, shard_count, replica_group_ids, channel_id)

• 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 เดียวกันเท่านั้นที่จะสื่อสารกันได้

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

AllReduce

โปรดดูXlaBuilder::AllReduce

ดำเนินการคํานวณที่กําหนดเองในข้อมูลจำลอง

AllReduce(operand, computation, replica_group_ids, channel_id)

• เมื่อ operand เป็นทูเปิลของอาร์เรย์ ระบบจะดำเนินการลดทั้งหมดกับองค์ประกอบแต่ละรายการของทูเปิล
• replica_groups คือรายการกลุ่มข้อมูลจำลองที่จะทำการลด (เรียกดูรหัสข้อมูลจำลองปัจจุบันได้โดยใช้ ReplicaId) replica_groups ต้องว่างเปล่า (ในกรณีที่ข้อมูลจำลองทั้งหมดอยู่ในกลุ่มเดียว) หรือมีองค์ประกอบเท่ากับจํานวนข้อมูลจำลอง ตัวอย่างเช่น replica_groups = {0, 2}, {1, 3} จะลดระหว่างข้อมูลจำลอง 0 กับ 2 และ 1 กับ 3
• channel_id ใช้สำหรับการสื่อสารข้ามโมดูล: เฉพาะall-reduceการดำเนินการที่มี channel_id เดียวกันเท่านั้นที่จะสื่อสารกันได้

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

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

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 ได้
• รูปร่างของออพอเรนดไม่ใช่ทูเปิล

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

ด้านล่างแสดงตัวอย่าง Alltoall

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]

BatchNormGrad

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

คำนวณอนุพันธ์ของการปรับมาตรฐานกลุ่ม

BatchNormGrad(operand, scale, mean, variance, 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} \]

อินพุต mean และ variance แสดงค่าช่วงเวลาในมิติข้อมูลกลุ่มและมิติข้อมูลเชิงพื้นที่

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

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 วัตถุประสงค์ของการดำเนินการนี้คือเพื่อลดเวลาในการตอบสนองในการอนุมาน จึงได้ชื่อว่า BatchNormInference

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

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\)

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

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

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

BitcastConvertType

โปรดดูXlaBuilder::BitcastConvertType

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

BitcastConvertType(operand, new_element_type)

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

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

การแปลงแบบบิตแคสต์เป็นประเภทพื้นฐานที่มีความกว้างต่างกัน

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)

โปรดทราบว่าการเปลี่ยนรูปแบบระหว่างความกว้างของบิตที่แตกต่างกันจะไม่เป็นแบบทีละองค์ประกอบ

ประกาศ

โปรดดูXlaBuilder::Broadcast

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

Broadcast(operand, broadcast_sizes)

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

มิติข้อมูลใหม่จะจัดทําดัชนีในสำเนาของออบเจ็กต์operand นั่นคือ

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

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

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, args...)

จำนวนอาร์กิวเมนต์และประเภทของ args ต้องตรงกับพารามิเตอร์ของ computation อนุญาตให้ไม่มี args

CompositeCall

โปรดดูXlaBuilder::CompositeCall

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

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

การดำเนินการนี้ติดตั้งใช้งานเป็น kCall ที่มีแอตทริบิวต์ is_composite=true แอตทริบิวต์ computation จะระบุช่อง decomposition แอตทริบิวต์ในฝั่งหน้าเว็บจะจัดเก็บแอตทริบิวต์ที่เหลือโดยนำหน้าด้วย 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"
}

Call(computation, args..., name, composite_attributes, version)

Cholesky

โปรดดูXlaBuilder::Cholesky

คํานวณการสลาย Cholesky ของเมทริกซ์เชิงบวกแน่นอนแบบสมมาตร (เฮอร์มิเทียน) หลายรายการ

Cholesky(a, lower)

หาก lower เป็น true ให้คํานวณเมทริกซ์สามเหลี่ยมล่าง l ดังที่ $a = l l^T$ หาก lower เป็น false ให้คำนวณเมทริกซ์สามเหลี่ยมมุมบน u ดังนี้ \(a = u^T . u\)

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

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

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

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

โปรดดูXlaBuilder::Clamp

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

Clamp(min, operand, max)

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

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

ตัวอย่างที่ใช้ Scalar 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};

ยุบ

โปรดดูหัวข้อ XlaBuilder::Collapse และการดำเนินการ tf.reshape ด้วย

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

Collapse(operand, dimensions)

การยุบจะแทนที่มิติข้อมูลย่อยของออพอเรนดัมด้วยมิติข้อมูลเดียว อาร์กิวเมนต์อินพุตคืออาร์เรย์ประเภท 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} };

CollectivePermute

โปรดดูXlaBuilder::CollectivePermute

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

CollectivePermute(operand, source_target_pairs)

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

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

ต่อ

โปรดดูXlaBuilder::ConcatInDim

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

Concatenate(operands..., dimension)

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

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

Concat({ {2, 3}, {4, 5}, {6, 7} }, 0)
>>> {2, 3, 4, 5, 6, 7}

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

let a = {
{1, 2},
{3, 4},
{5, 6},
};
let b = {
{7, 8},
};
Concat({a, b}, 0)
>>> {
{1, 2},
{3, 4},
{5, 6},
{7, 8},
}

แผนภาพ

มีเงื่อนไข

โปรดดูXlaBuilder::Conditional

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

ดำเนินการ true_computation หาก pred เป็น true, false_computation หาก pred เป็น false และแสดงผลลัพธ์

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

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

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] แต่ละรายการต้องเหมือนกัน

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

Conv (Convolution)

โปรดดูXlaBuilder::Conv

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

ConvWithGeneralPadding (Convolution)

โปรดดูXlaBuilder::ConvWithGeneralPadding

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

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

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

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

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

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

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

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

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

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

สําหรับการกรองเชิงลึก ระบบจะตั้งค่าอาร์กิวเมนต์ 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 ค่าสําหรับตําแหน่งหน้าต่างการกรองเชิงConvolutive ที่ถูกต้องแต่ละรายการ

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

ตําแหน่งที่ถูกต้องของกรอบ Convolutional จะกําหนดโดยระยะการเลื่อนและขนาดของพื้นที่ฐานหลังจากการเติม

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

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

โค้ดจำลองสำหรับการฟัซซิเนชัน 2 มิติที่มีการเติมและการเพิ่มระยะห่างมีดังนี้

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;
}

ConvertElementType

โปรดดูXlaBuilder::ConvertElementType

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

ConvertElementType(operand, new_element_type)

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

การแปลง เช่น 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}

CrossReplicaSum

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

CustomCall

โปรดดูXlaBuilder::CustomCall

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

CustomCall(target_name, args..., shape)

ลายเซ็นฟังก์ชันจะเหมือนกัน ไม่ว่าจำนวนอาร์กิวเมนต์หรือประเภทของอาร์กิวเมนต์จะเป็นแบบใดก็ตาม

extern "C" void target_name(void* out, void** in);

เช่น หากใช้ CustomCall ดังนี้

let x = f32[2] {1,2};
let y = f32[2x3] { {10, 20, 30}, {40, 50, 60} };

CustomCall("myfunc", {x, y}, f32[3x3])

ตัวอย่างการใช้งาน myfunc มีดังนี้

extern "C" void myfunc(void* out, void** in) {
  float (&x)[2] = *static_cast<float(*)[2]>(in[0]);
  float (&y)[2][3] = *static_cast<float(*)[2][3]>(in[1]);
  EXPECT_EQ(1, x[0]);
  EXPECT_EQ(2, x[1]);
  EXPECT_EQ(10, y[0][0]);
  EXPECT_EQ(20, y[0][1]);
  EXPECT_EQ(30, y[0][2]);
  EXPECT_EQ(40, y[1][0]);
  EXPECT_EQ(50, y[1][1]);
  EXPECT_EQ(60, y[1][2]);
  float (&z)[3][3] = *static_cast<float(*)[3][3]>(out);
  z[0][0] = x[1] + y[1][0];
  // ...
}

ฟังก์ชันที่ผู้ใช้ระบุต้องไม่มีผลข้างเคียง และการเรียกใช้ต้องเป็นแบบ idempotent

จุด

โปรดดูXlaBuilder::Dot

Dot(lhs, rhs)

ความหมายที่แน่นอนของการดำเนินการนี้ขึ้นอยู่กับลําดับของออบเจ็กต์operand ดังนี้

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

DotGeneral

โปรดดูXlaBuilder::DotGeneral

DotGeneral(lhs, rhs, dimension_numbers)

คล้ายกับ 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มิติข้อมูลที่ไม่ทำสัญญา/ไม่ใช่กลุ่ม

DynamicSlice

โปรดดูXlaBuilder::DynamicSlice

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

DynamicSlice(operand, start_indices, size_indices)

ระบบจะคํานวณดัชนีส่วนที่มีประสิทธิภาพโดยใช้การเปลี่ยนรูปแบบต่อไปนี้สําหรับแต่ละดัชนี i ใน [1, N) ก่อนทำการแบ่ง

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

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

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

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

DynamicSlice(a, s, {2}) produces:
{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}) produces:
{ { 7.0,  8.0},
{10.0, 11.0} }

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])

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

ตัวอย่างแบบ 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) produces:
{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) produces:
{ {0.0,  1.0,  2.0},
{3.0, 12.0, 13.0},
{6.0, 14.0, 15.0},
{9.0, 16.0, 17.0} }

การดำเนินการทางคณิตศาสตร์แบบไบนารีตามองค์ประกอบ

โปรดดูXlaBuilder::Add

รองรับชุดการดำเนินการทางคณิตศาสตร์แบบไบนารีตามองค์ประกอบ

Op(lhs, rhs)

โดยที่ Op เป็นหนึ่งใน Add (การบวก), Sub(การลบ), Mul (การคูณ), Div (การหาร), Pow (การยกกำลัง), Rem (เศษ), Max (ค่าสูงสุด), Min (ค่าต่ำสุด), And (การ AND เชิงตรรกะ), Or (การ OR เชิงตรรกะ), Xor (การ XOR เชิงตรรกะ), ShiftLeft (การเลื่อนไปทางซ้าย), ShiftRightArithmetic (การเลื่อนไปทางขวาแบบเชิงตัวเลข), ShiftRightLogical (การเลื่อนไปทางขวาแบบเชิงตรรกะ), Atan2 (อาร์คแทนเจนต์ 2 อาร์กิวเมนต์) หรือ Complex (รวมส่วนจริงและส่วนจินตนาการเข้าด้วยกันเป็นจำนวนเชิงซ้อน)

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

เมื่อ Op เป็น Rem ระบบจะนำเครื่องหมายของผลลัพธ์มาจากตัวหาร และค่าสัมบูรณ์ของผลลัพธ์จะน้อยกว่าค่าสัมบูรณ์ของตัวหารเสมอ

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

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

Op(lhs, rhs, broadcast_dimensions)

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

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

การดำเนินการเปรียบเทียบแบบองค์ประกอบ

โปรดดูXlaBuilder::Eq

รองรับชุดการดำเนินการเปรียบเทียบแบบไบนารีตามองค์ประกอบมาตรฐาน โปรดทราบว่านิพจน์เปรียบเทียบที่เป็นจุดทศนิยม IEEE 754 มาตรฐานจะมีผลเมื่อเปรียบเทียบประเภทที่เป็นจุดทศนิยม

Op(lhs, rhs)

โดยที่ Op เป็นหนึ่งใน Eq (เท่ากับ), Ne (ไม่เท่ากับ), Ge (มากกว่าหรือเท่ากับ), Gt (มากกว่า), Le (น้อยกว่าหรือเท่ากับ), Lt (น้อยกว่า) โอเปอเรเตอร์ชุดอื่นอย่าง EqTotalOrder, NeTotalOrder, GeTotalOrder, GtTotalOrder, LeTotalOrder และ LtTotalOrder มีฟังก์ชันการทำงานแบบเดียวกัน ยกเว้นว่ารองรับลําดับเชิงสมบูรณ์เพิ่มเติมสําหรับตัวเลขทศนิยม โดยบังคับใช้ -NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN

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

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

Op(lhs, rhs, broadcast_dimensions)

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

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

ฟังก์ชันเอกรูปตามองค์ประกอบ

XlaBuilder รองรับฟังก์ชันเอกรูปตามองค์ประกอบต่อไปนี้

Abs(operand) ผลลัพธ์ abs ตามองค์ประกอบ x -> |x|

Cbrt(operand) การดำเนินการหารากคิวบิกตามองค์ประกอบ x -> cbrt(x)

Ceil(operand) การปัดเศษขึ้นตามองค์ประกอบ x -> ⌈x⌉

Clz(operand) นับเลข 0 นําหน้าตามองค์ประกอบ

Cos(operand) โคไซน์ตามองค์ประกอบ x -> cos(x)

Erf(operand) ฟังก์ชันค่าคลาดเคลื่อนระดับองค์ประกอบ x -> erf(x) โดยที่

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

Exp(operand) Exponential ธรรมชาติตามองค์ประกอบ x -> e^x

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

Floor(operand) พื้นตามองค์ประกอบ x -> ⌊x⌋

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

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

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

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

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

Neg(operand) การปฏิเสธแบบองค์ประกอบ x -> -x

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

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

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

Round(operand) การปัดเศษองค์ประกอบทีละรายการ โดยปัดเศษออกจาก 0

RoundNearestEven(operand) การปัดเศษองค์ประกอบตามลำดับ ปัดไปเป็นจำนวนคู่ที่ใกล้ที่สุด

Rsqrt(operand) ตัวผกผันการดำเนินการรากที่สองตามองค์ประกอบ x -> 1.0 / sqrt(x)

Sign(operand) การดำเนินการเกี่ยวกับเครื่องหมายขององค์ประกอบ x -> sgn(x) โดยที่

\[\text{sgn}(x) = \begin{cases} -1 & x < 0\\ -0 & x = -0\\ NaN & x = NaN\\ +0 & x = +0\\ 1 & x > 0 \end{cases}\]

โดยใช้โอเปอเรเตอร์การเปรียบเทียบขององค์ประกอบประเภท operand

Sin(operand) ไซน์ตามองค์ประกอบ x -> sin(x)

Sqrt(operand) การดำเนินการหารากที่สองตามองค์ประกอบ x -> sqrt(x)

Tan(operand) Tangens ตามองค์ประกอบ x -> tan(x)

Tanh(operand) ไฮเพอร์โบลิกแทนเจนต์ตามองค์ประกอบ x -> tanh(x)

ระบบจะใช้ฟังก์ชันกับองค์ประกอบแต่ละรายการในอาร์เรย์ operand ซึ่งจะให้ผลลัพธ์เป็นอาร์เรย์ที่มีรูปร่างเหมือนกัน อนุญาตให้ operand เป็นค่าสเกลาร์ (0 มิติ)

Fft

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

โปรดดูXlaBuilder::Fft

FFT หลายมิติ

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

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

FFT ของ CPU ทำงานด้วย TensorFFT ของ Eigen FFT ของ GPU ใช้ cuFFT

รวบรวม

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

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

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

gather(operand, start_indices, offset_dims, collapsed_slice_dims, slice_sizes, start_index_map)

เราติดป้ายกํากับมิติข้อมูลในอาร์เรย์เอาต์พุตที่ไม่ใช่ใน 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)] โดยที่ G แทรก 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 จะไม่เปลี่ยนแปลงการดำเนินการโดยพื้นฐาน แต่ทําให้การแสดงภาพยุ่งยากมากขึ้น

มาดูตัวอย่างที่รวบรวมรูปทรง [8,6] 5 ชิ้นจากอาร์เรย์ [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₁ ซึ่งจะเป็นตัวกำหนดขอบเขตของส่วน

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

ดัชนีการรวบรวมอาจเป็นมิติข้อมูลหลายมิติ ตัวอย่างเช่น ตัวอย่างข้างต้นเวอร์ชันทั่วไปมากขึ้นซึ่งใช้อาร์เรย์ "gather indices" ของรูปร่าง [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 อย่างไรก็ตาม ก่อนที่จะใช้เป็นดัชนีในอาร์เรย์อินพุต ระบบจะขยายค่าเหล่านี้ตาม "การแมปดัชนีการรวบรวม" (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)

SetDimensionSize

โปรดดูXlaBuilder::SetDimensionSize

กำหนดขนาดแบบไดนามิกของมิติข้อมูลที่ระบุของ XlaOp ออบเจ็กต์ต้องอยู่ในรูปแบบอาร์เรย์

SetDimensionSize(operand, size, dimension)

ส่งผ่านออบเจ็กต์เป็นผลลัพธ์ โดยมีมิติข้อมูลแบบไดนามิกที่คอมไพเลอร์ติดตาม

การดำเนินการลดปลายทางจะไม่สนใจค่าที่เพิ่มการเติม

let v: f32[10] = f32[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
let five: s32 = 5;
let six: s32 = 6;

// Setting dynamic dimension size doesn't change the upper bound of the static
// shape.
let padded_v_five: f32[10] = set_dimension_size(v, five, /*dimension=*/0);
let padded_v_six: f32[10] = set_dimension_size(v, six, /*dimension=*/0);

// sum == 1 + 2 + 3 + 4 + 5
let sum:f32[] = reduce_sum(padded_v_five);
// product == 1 * 2 * 3 * 4 * 5
let product:f32[] = reduce_product(padded_v_five);

// Changing padding size will yield different result.
// sum == 1 + 2 + 3 + 4 + 5 + 6
let sum:f32[] = reduce_sum(padded_v_six);

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

ในสตรีม

โปรดดูXlaBuilder::Infeed

Infeed(shape)

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

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

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

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

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 ]]

แผนที่

โปรดดูXlaBuilder::Map

Map(operands..., computation)

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

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

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

OptimizationBarrier

บล็อกไม่ให้การเพิ่มประสิทธิภาพย้ายการประมวลผลข้ามสิ่งกีดขวาง

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

แผ่น

โปรดดู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 ระบุจำนวนการถ่วงที่เพิ่มไว้ที่ปลายต่ำ (ถัดจากดัชนี 0) และปลายสูง (ถัดจากดัชนีสูงสุด) ของมิติข้อมูลแต่ละรายการตามลำดับ จำนวนการเว้นขอบอาจเป็นค่าลบได้ โดยค่าสัมบูรณ์ของการเว้นขอบเชิงลบจะระบุจํานวนองค์ประกอบที่จะนําออกจากมิติข้อมูลที่ระบุ

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

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

Recv

โปรดดูXlaBuilder::Recv

Recv(shape, channel_handle)

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

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

Recv(const Shape& shape, int64 channel_id)

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

RecvDone(HloInstruction context)

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

ลด (Reduce)

โปรดดูXlaBuilder::Reduce

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

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

สถานที่:

• โดย 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) เอาต์พุตของการดำเนินการคือ Collate(Q_0, ..., Q_N) โดยที่ Q_i คืออาร์เรย์ประเภท T_i ซึ่งอธิบายมิติข้อมูลไว้ด้านล่าง

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

ตัวอย่าง

เมื่อลดมิติข้อมูลเดียวในอาร์เรย์ 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 และคํานวณขนาด 3 ดังนี้

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

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

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

ในทำนองเดียวกับตัวอย่าง 2 มิติ เราสามารถลดมิติข้อมูลได้เพียง 1 มิติ เช่น หากลดมิติข้อมูล 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

เมื่อเป็น 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, mantissa_bits, exponent_bits)

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

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

ReduceScatter

โปรดดูXlaBuilder::ReduceScatter

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

ReduceScatter(operand, computation, scatter_dim, shard_count, replica_group_ids, channel_id)

• เมื่อ 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 เดียวกันเท่านั้นที่จะสื่อสารกันได้

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

ReduceWindow

โปรดดูXlaBuilder::ReduceWindow

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

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})

โค้ดและรูปภาพด้านล่างแสดงตัวอย่างการใช้ ReduceWindow อินพุตคือเมทริกซ์ขนาด [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);

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

สําหรับตัวอย่างการเติมที่ไม่ง่ายนัก ให้พิจารณาคํานวณค่าต่ำสุดของกรอบเวลาการลด (ค่าเริ่มต้นคือ MAX_FLOAT) ที่มีมิติข้อมูล 3 และระยะห่าง 2 ในอาร์เรย์อินพุต [10000, 1000, 100, 10, 1] การป้อนค่าเพิ่ม kValid จะคํานวณค่าต่ำสุดในกรอบเวลา 2 กรอบที่ถูกต้อง ได้แก่ [10000, 1000, 100] และ [100, 10, 1] ซึ่งจะให้ผลลัพธ์เป็น [100, 1] การป้อนค่าเพิ่ม kSame จะเพิ่มค่าลงในอาร์เรย์ก่อนเพื่อให้รูปร่างหลังจาก reduce-window เหมือนกันกับอินพุตสำหรับระยะ 1 โดยการใส่องค์ประกอบเริ่มต้นไว้ทั้ง 2 ด้าน ซึ่งจะได้ [MAX_VALUE, 10000, 1000, 100, 10, 1, MAX_VALUE] การใช้ reduce-window กับอาร์เรย์ที่มีการถอดส่วนเกินออกจะดำเนินการกับ 3 กรอบเวลา [MAX_VALUE, 10000, 1000], [1000, 100, 10], [10, 1, MAX_VALUE] และได้ผลลัพธ์เป็น [1000, 10, 1]

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

ReplicaId

โปรดดูXlaBuilder::ReplicaId

แสดงผลรหัสที่ไม่ซ้ำกัน (สเกลาร์ U32) ของข้อมูลจำลอง

ReplicaId()

รหัสที่ไม่ซ้ำกันของรีพลิคาแต่ละรายการคือจำนวนเต็มแบบไม่ลงนามในช่วง [0, N) โดยที่ N คือจํานวนรีพลิคา เนื่องจากรีเพลซิคาทั้งหมดทํางานในโปรแกรมเดียวกัน การเรียกใช้ ReplicaId() ในโปรแกรมจะแสดงผลค่าที่แตกต่างกันในรีเพลซิคาแต่ละรายการ

ปรับรูปร่าง

โปรดดูหัวข้อ XlaBuilder::Reshape และการดำเนินการ Collapse ด้วย

เปลี่ยนรูปร่างของมิติข้อมูลของอาร์เรย์เป็นการกําหนดค่าใหม่

Reshape(operand, dimensions)

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

ตัวอย่างเช่น สมมติให้ 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} } };

let v012_24 = Reshape(v, {24});
then v012_24 == 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};

let v012_83 = Reshape(v, {8,3});
then v012_83 == 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} };

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

Reshape(f32[1x1] { {5} }, {}) == 5;
Reshape(5, {1,1}) == f32[1x1] { {5} };

Rev (ย้อนกลับ)

โปรดดูXlaBuilder::Rev

Rev(operand, dimensions)

กลับลําดับขององค์ประกอบในอาร์เรย์ operand ตาม dimensions ที่ระบุ ซึ่งจะสร้างอาร์เรย์เอาต์พุตที่มีรูปร่างเดียวกัน ระบบจะจัดเก็บองค์ประกอบแต่ละรายการของอาร์เรย์โอเปอเรนด์ที่ดัชนีมัลติไดเมนชันไว้ในอาร์เรย์เอาต์พุตที่ดัชนีที่เปลี่ยนรูปแบบ ดัชนีมิติข้อมูลหลายมิติจะเปลี่ยนรูปแบบโดยการกลับดัชนีในแต่ละมิติข้อมูลที่จะเปลี่ยน (กล่าวคือ หากมิติข้อมูลขนาด N เป็นหนึ่งในมิติข้อมูลที่เปลี่ยนรูปแบบ ดัชนี i ของมิติข้อมูลดังกล่าวจะเปลี่ยนเป็น N - 1 - i)

การใช้งานอย่างหนึ่งของการดำเนินการ Rev คือการเปลี่ยนลําดับอาร์เรย์น้ำหนักการกรองตามปริภูมิของกรอบเวลา 2 รายการในระหว่างการคํานวณอนุพันธ์ในเครือข่ายประสาทเทียม

RngNormal

โปรดดูXlaBuilder::RngNormal

สร้างเอาต์พุตของรูปร่างหนึ่งๆ ด้วยตัวเลขสุ่มที่สร้างขึ้นตาม \(N(\mu, \sigma)\) การแจกแจงแบบปกติ พารามิเตอร์ \(\mu\) และ \(\sigma\)รวมถึงรูปแบบเอาต์พุตต้องมีประเภทองค์ประกอบจำนวนจุดลอยตัว นอกจากนี้ พารามิเตอร์ต้องมีค่าสเกลาร์

RngNormal(mu, sigma, shape)

RngUniform

โปรดดูXlaBuilder::RngUniform

สร้างเอาต์พุตของรูปร่างหนึ่งๆ ด้วยตัวเลขสุ่มที่สร้างขึ้นตามการแจกแจงแบบสม่ำเสมอในช่วง \([a,b)\)พารามิเตอร์และประเภทองค์ประกอบเอาต์พุตต้องเป็นประเภทบูลีน ประเภทจำนวนเต็ม หรือประเภททศนิยม และประเภทต้องสอดคล้องกัน ปัจจุบันแบ็กเอนด์ของ CPU และ GPU รองรับเฉพาะ F64, F32, F16, BF16, S64, U64, S32 และ U32 นอกจากนี้ พารามิเตอร์ต้องเป็นค่าสเกลาร์ หาก \(b <= a\) ผลลัพธ์คือการดำเนินการที่กําหนด

RngUniform(a, b, shape)

RngBitGenerator

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

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

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

RngBitGenerator(algorithm, key, shape)

ค่าที่ใช้ได้มีดังนี้algorithm

• rng_default: อัลกอริทึมเฉพาะแบ็กเอนด์ที่มีข้อกำหนดเฉพาะสำหรับรูปร่างของแบ็กเอนด์

• rng_three_fry: อัลกอริทึม PRNG ที่อิงตามตัวนับ ThreeFry initial_state รูปร่างคือ u64[2] ที่มีค่าใดก็ได้ Salmon et al. SC 2011. ตัวเลขสุ่มแบบขนาน: ง่ายเหมือนนับ 1 2 3

• rng_philox: อัลกอริทึม Philox เพื่อสร้างตัวเลขสุ่มแบบขนาน รูปร่าง initial_state คือ u64[3] ที่มีค่าใดก็ได้ Salmon et al. SC 2011. ตัวเลขสุ่มแบบขนาน: ง่ายเหมือนนับ 1 2 3

แผนภูมิกระจาย

การดำเนินการกระจาย XLA จะสร้างลำดับผลลัพธ์ซึ่งเป็นค่าของอาร์เรย์อินพุต operands โดยมีหลายส่วน (ที่ดัชนีที่ระบุโดย scatter_indices) ที่อัปเดตด้วยลำดับค่าใน updates โดยใช้ update_computation

โปรดดูXlaBuilder::Scatter

scatter(operands..., scatter_indices, updates..., update_computation, index_vector_dim, update_window_dims, inserted_window_dims, scatter_dims_to_operand_dims)

สถานที่:

• โดย N ต้องมากกว่าหรือเท่ากับ 1
• operands[0], ..., operands[N-1] ทั้งหมดต้องมีมิติข้อมูลเดียวกัน
• updates[0], ..., updates[N-1] ทั้งหมดต้องมีมิติข้อมูลเดียวกัน
• หาก N = 1 Collate(T) คือ T
• หากเป็น N > 1 Collate(T_0, ..., T_N) คือทูเปิลขององค์ประกอบ N ประเภท T

หาก index_vector_dim เท่ากับ scatter_indices.rank เราจะถือว่า scatter_indices มีค่ามิติข้อมูล 1 ต่อท้ายโดยปริยาย

เรากําหนด update_scatter_dims ประเภท ArraySlice<int64> เป็นชุดมิติข้อมูลในรูปทรง updates ที่ไม่ได้อยู่ใน update_window_dims โดยเรียงตามลําดับจากน้อยไปมาก

อาร์กิวเมนต์ของ Scatter ควรเป็นไปตามข้อจำกัดต่อไปนี้

• อาร์เรย์ updates แต่ละรายการต้องมีมิติข้อมูล update_window_dims.size + scatter_indices.rank - 1

• ขอบเขตของมิติข้อมูล i ในอาร์เรย์ updates แต่ละรายการต้องเป็นไปตามข้อกำหนดต่อไปนี้

  • หาก i อยู่ใน update_window_dims (นั่นคือ เท่ากับ update_window_dims[k] สำหรับ k บางรายการ) ขอบเขตของมิติข้อมูล i ใน updates ต้องไม่เกินขอบเขตที่เกี่ยวข้องของ operand หลังจากพิจารณา inserted_window_dims แล้ว (นั่นคือ adjusted_window_bounds[k] โดยที่ adjusted_window_bounds มีขอบเขตของ operand โดยนำขอบเขตที่ดัชนี inserted_window_dims ออก)
  • หาก i อยู่ใน update_scatter_dims (นั่นคือ เท่ากับ update_scatter_dims[k] สำหรับ k บางรายการ) ขอบเขตของมิติข้อมูล i ใน updates จะต้องเท่ากับขอบเขตที่สอดคล้องกันของ scatter_indices โดยข้าม index_vector_dim (นั่นคือ scatter_indices.shape.dims[k] หาก k < index_vector_dim และ scatter_indices.shape.dims[k+1] ในกรณีอื่นๆ)

• update_window_dims ต้องเรียงตามลําดับจากน้อยไปมาก ไม่มีหมายเลขมิติข้อมูลที่ซ้ำกัน และอยู่ในช่วง [0, updates.rank)

• inserted_window_dims ต้องเรียงตามลําดับจากน้อยไปมาก ไม่มีหมายเลขมิติข้อมูลที่ซ้ำกัน และอยู่ในช่วง [0, operand.rank)

• operand.rank ต้องเท่ากับผลรวมของ update_window_dims.size และ inserted_window_dims.size

• scatter_dims_to_operand_dims.size ต้องเท่ากับ scatter_indices.shape.dims[index_vector_dim] และค่าของ scatter_dims_to_operand_dims.size ต้องอยู่ในช่วง [0, operand.rank)

สําหรับดัชนี U หนึ่งๆ ในอาร์เรย์ updates แต่ละรายการ ระบบจะคํานวณดัชนี I ที่สอดคล้องกันในอาร์เรย์ operands ที่สอดคล้องกันซึ่งต้องได้รับการอัปเดตนี้ดังนี้

1. สมมติให้ G = { U[k] สำหรับ k ใน update_scatter_dims } ใช้ G เพื่อค้นหาเวกเตอร์อินเด็กซ์ S ในอาร์เรย์ scatter_indices โดยที่ S[i] = scatter_indices[Combine(G, i)] โดยที่ Combine(A, b) จะแทรก b ที่ตําแหน่ง index_vector_dim ลงใน A
2. สร้างดัชนี Sin ใน operand โดยใช้ S โดยการกระจาย S โดยใช้แผนที่ scatter_dims_to_operand_dims รูปแบบที่เป็นทางการคือ
   1. Sin[scatter_dims_to_operand_dims[k]] = S[k] if k < scatter_dims_to_operand_dims.size
   2. Sin[_] = 0 ในกรณีอื่น
3. สร้างดัชนี Win ลงในอาร์เรย์ operands แต่ละรายการโดยการกระจายดัชนีที่ update_window_dims ใน U ตาม inserted_window_dims รูปแบบที่เป็นทางการคือ
   1. Win[window_dims_to_operand_dims(k)] = U[k] หาก kอยู่ใน update_window_dims โดยที่ window_dims_to_operand_dims เป็นฟังก์ชันแบบ Monotonic ที่มีโดเมน [0, update_window_dims.size) และช่วง [0, operand.rank) \ inserted_window_dims (เช่น หาก update_window_dims.size คือ 4, operand.rank คือ 6 และ inserted_window_dims คือ {0, 2} window_dims_to_operand_dims จะเป็น {0→1, 1→3, 2→4, 3→5})
   2. Win[_] = 0 ในกรณีอื่น
4. I คือ Win + Sin โดยที่ + คือการบวกทีละองค์ประกอบ

โดยสรุปแล้ว การดำเนินการ Scatter จะกำหนดได้ดังนี้

• เริ่มต้น output ด้วย operands กล่าวคือสําหรับดัชนี J ทั้งหมด สําหรับดัชนี O ทั้งหมดในอาร์เรย์ operands[J]:
  output[J][O] = operands[J][O]
• สําหรับดัชนี U ทั้งหมดในอาร์เรย์ updates[J] และดัชนีที่เกี่ยวข้อง O ในอาร์เรย์ operand[J] หาก O เป็นดัชนีที่ถูกต้องสําหรับ output:
  (output[0][O], ..., output[N-1][O]) =update_computation(output[0][O], ..., ,output[N-1][O],updates[0][U], ...,updates[N-1][U])

ลำดับการใช้การอัปเดตนั้นไม่แน่นอน ดังนั้น เมื่อดัชนีหลายรายการใน updates อ้างอิงถึงดัชนีเดียวกันใน operands ค่าที่เกี่ยวข้องใน output จะไม่ใช่ค่าที่แน่นอน

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

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

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

ในทางเทคนิค คุณสามารถมองการดำเนินการ Scatter เป็นการดำเนินการผกผันของการดำเนินการ Gather กล่าวคือ การดำเนินการ Scatter จะอัปเดตองค์ประกอบในอินพุตที่ดึงมาจากการดำเนินการ Gather ที่เกี่ยวข้อง

ดูคำอธิบายและตัวอย่างแบบไม่เป็นทางการโดยละเอียดได้ที่ส่วน "คำอธิบายแบบไม่เป็นทางการ" ในส่วน Gather

เลือก

โปรดดูXlaBuilder::Select

สร้างอาร์เรย์เอาต์พุตจากองค์ประกอบของอาร์เรย์อินพุต 2 รายการ โดยอิงตามค่าของอาร์เรย์พริเนกต์

Select(pred, on_true, on_false)

อาร์เรย์ on_true และ on_false ต้องมีรูปร่างเหมือนกัน ซึ่งก็คือรูปแบบของอาร์เรย์เอาต์พุตด้วย อาร์เรย์ pred ต้องมีมิติข้อมูลเหมือนกับ on_true และ on_false โดยมีประเภทองค์ประกอบเป็น PRED

สําหรับองค์ประกอบ P แต่ละรายการของ pred ระบบจะนําองค์ประกอบที่สอดคล้องกันของอาร์เรย์เอาต์พุตจาก on_true หากค่าของ P เป็น true และจาก on_false หากค่าของ P เป็น false pred อาจเป็นสเกลาร์ประเภท PRED เนื่องจากเป็นรูปแบบการออกอากาศแบบจํากัด ในกรณีนี้ ระบบจะนำอาร์เรย์เอาต์พุตทั้งหมดจาก on_true หาก pred เป็น true และจาก on_false หาก pred เป็น false

ตัวอย่างที่มี pred ไม่ใช่สเกลาร์

let pred: PRED[4] = {true, false, false, true};
let v1: s32[4] = {1, 2, 3, 4};
let v2: s32[4] = {100, 200, 300, 400};
==>
Select(pred, v1, v2) = s32[4]{1, 200, 300, 4};

ตัวอย่างที่ใช้ Scalar pred

let pred: PRED = true;
let v1: s32[4] = {1, 2, 3, 4};
let v2: s32[4] = {100, 200, 300, 400};
==>
Select(pred, v1, v2) = s32[4]{1, 2, 3, 4};

ระบบรองรับการเลือกระหว่างทูเพลต ระบบจะถือว่าทูเปิลเป็นประเภทสเกลาร์สำหรับวัตถุประสงค์นี้ หาก on_true และ on_false เป็นทูเพล (ซึ่งต้องมีรูปร่างเหมือนกัน) pred ต้องเป็นสเกลาร์ประเภท PRED

SelectAndScatter

โปรดดูXlaBuilder::SelectAndScatter

การดำเนินการนี้ถือได้ว่าเป็นการดำเนินการแบบคอมโพสิทที่เริ่มด้วยการคำนวณ ReduceWindow ในอาร์เรย์ operand เพื่อเลือกองค์ประกอบจากแต่ละกรอบเวลา แล้วกระจายอาร์เรย์ source ไปยังอินเด็กซ์ขององค์ประกอบที่เลือกเพื่อสร้างอาร์เรย์เอาต์พุตที่มีรูปร่างเหมือนกับอาร์เรย์ออบเจ็กต์ ฟังก์ชันไบนารี select ใช้เพื่อเลือกองค์ประกอบจากแต่ละกรอบเวลาโดยใช้กับแต่ละกรอบเวลา และเรียกใช้ด้วยพร็อพเพอร์ตี้ที่เวกเตอร์อินเด็กซ์ของพารามิเตอร์แรกมีค่าน้อยกว่าเวกเตอร์อินเด็กซ์ของพารามิเตอร์ที่ 2 ตามลําดับตัวอักษร ฟังก์ชัน select จะแสดงผลเป็น true หากเลือกพารามิเตอร์แรก และแสดงผลเป็น false หากเลือกพารามิเตอร์ที่ 2 และฟังก์ชันต้องเป็นไปตามหลักการสื่อกลาง (กล่าวคือ หาก select(a, b) และ select(b, c) เป็น true select(a, c) ก็เป็น true ด้วย) เพื่อให้องค์ประกอบที่เลือกไม่ขึ้นอยู่กับลําดับขององค์ประกอบที่ไปยังส่วนต่างๆ สําหรับกรอบเวลาหนึ่งๆ

ระบบจะใช้ฟังก์ชัน scatter ที่แต่ละดัชนีที่เลือกในอาร์เรย์เอาต์พุต โดยจะใช้พารามิเตอร์สเกลาร์ 2 รายการ ดังนี้

1. ค่าปัจจุบันที่ดัชนีที่เลือกในอาร์เรย์เอาต์พุต
2. ค่าการกระจายจาก source ที่มีผลกับดัชนีที่เลือก

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

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

SelectAndScatter(operand, select, window_dimensions, window_strides, padding, source, init_value, scatter)

รูปภาพด้านล่างแสดงตัวอย่างการใช้ SelectAndScatter โดยฟังก์ชัน select จะคํานวณค่าสูงสุดจากพารามิเตอร์ โปรดทราบว่าเมื่อกรอบเวลาซ้อนทับกัน ดังในรูปภาพ (2) ด้านล่าง กรอบเวลาต่างๆ อาจเลือกดัชนีของอาร์เรย์ operand หลายครั้ง ในรูปภาพ องค์ประกอบที่มีค่า 9 ได้รับการเลือกโดยทั้ง 2 หน้าต่างด้านบน (สีน้ำเงินและสีแดง) และฟังก์ชันการเพิ่มแบบไบนารี scatter จะสร้างองค์ประกอบเอาต์พุตที่มีค่า 8 (2 + 6)

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

ส่ง

โปรดดูXlaBuilder::Send

Send(operand, channel_handle)

ส่งข้อมูลโอเปอเรนด์ที่ระบุไปยังคำสั่ง Recv ในการคำนวณอื่นที่ใช้แฮนเดิลแชแนลเดียวกัน ไม่แสดงข้อมูลใดๆ

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

Send(HloInstruction operand, int64 channel_id)

เริ่มการโอนแบบไม่พร้อมกันของออพเพอร์แรนด์ไปยังทรัพยากรที่จัดสรรโดยคำสั่ง Recv ที่มีรหัสแชแนลเดียวกัน แสดงผลบริบท ซึ่งSendDoneคำสั่งต่อไปนี้จะใช้เพื่อรอให้โอนข้อมูลเสร็จสมบูรณ์ บริบทคือทูเปิลของ {operand (shape), request identifier (U32)} และสามารถใช้ได้กับคำสั่ง SendDone เท่านั้น

SendDone(HloInstruction context)

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

การกำหนดเวลาของวิธีการในช่อง

ลําดับการดําเนินการของคําสั่ง 4 รายการสําหรับแต่ละแชแนล (Recv, RecvDone, Send, SendDone) มีดังนี้

• Recv เกิดขึ้นก่อน Send
• Send เกิดขึ้นก่อน RecvDone
• Recv เกิดขึ้นก่อน RecvDone
• Send เกิดขึ้นก่อน SendDone

เมื่อคอมไพเลอร์แบ็กเอนด์สร้างกําหนดการเชิงเส้นสําหรับการคํานวณแต่ละรายการที่สื่อสารผ่านคำสั่งช่องทาง การคํานวณต้องไม่มีรอบ ตัวอย่างเช่น กําหนดการด้านล่างทําให้เกิดการล็อกตาย

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

Slice

โปรดดูXlaBuilder::Slice

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

Slice(operand, start_indices, limit_indices, strides)

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

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
Slice(a, {2}, {4}) produces:
  {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} }

Slice(b, {2, 1}, {4, 3}) produces:
  { { 7.0,  8.0},
    {10.0, 11.0} }

จัดเรียง

โปรดดูXlaBuilder::Sort

Sort(operands, comparator, dimension, is_stable)

หากระบุโอเปอเรนด์เพียงรายการเดียว

• หากโอเปอเรนด์เป็นเทนเซอร์ 1 มิติ (อาร์เรย์) ผลลัพธ์จะเป็นอาร์เรย์ที่จัดเรียง หากต้องการจัดเรียงอาร์เรย์ตามลําดับจากน้อยไปมาก ตัวเปรียบเทียบควรทําการเปรียบเทียบน้อยกว่า ในทางเทคนิคแล้ว หลังจากที่จัดเรียงอาร์เรย์แล้ว เงื่อนไขนี้จะมีผลกับตำแหน่งดัชนี i, j ทั้งหมดที่มี i < j ซึ่งไม่ว่าจะมีค่าเป็น comparator(value[i], value[j]) = comparator(value[j], value[i]) = false หรือ comparator(value[i], value[j]) = true

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

หากระบุโอเปอเรนด์ n > 1 รายการ

• ออบเจ็กต์ n ทั้งหมดต้องเป็นเทนเซอร์ที่มีมิติข้อมูลเดียวกัน ประเภทองค์ประกอบของเทนเซอร์อาจแตกต่างกัน

• ระบบจะจัดเรียงโอเปอเรนดทั้งหมดพร้อมกัน ไม่ใช่แยกกัน ในทางแนวคิดแล้ว ระบบจะถือว่าโอเปอเรนดคือทูเปิล เมื่อตรวจสอบว่าต้องสลับองค์ประกอบของโอเปอเรนดแต่ละรายการที่ตําแหน่งอินเด็กซ์ i และ j หรือไม่ ระบบจะเรียกใช้ตัวเปรียบเทียบด้วยพารามิเตอร์สเกลาร์ 2 * n โดยที่พารามิเตอร์ 2 * k สอดคล้องกับค่าที่ตําแหน่ง i จากโอเปอเรนด k-th และพารามิเตอร์ 2 * k + 1 สอดคล้องกับค่าที่ตําแหน่ง j จากโอเปอเรนด k-th โดยปกติแล้ว ตัวเปรียบเทียบจะเปรียบเทียบพารามิเตอร์ 2 * k กับ 2 * k + 1 และอาจใช้คู่พารามิเตอร์อื่นๆ เป็นตัวตัดสินในกรณีที่เสมอกัน

• ผลลัพธ์คือทูเปิลที่ประกอบด้วยออบเจ็กต์การดำเนินการตามลําดับที่เรียงลําดับ (ตามมิติข้อมูลที่ระบุไว้ดังด้านบน) ออบเจ็กต์ i-th ของทูเปิลจะสอดคล้องกับออบเจ็กต์ i-th ของ Sort

เช่น หากมีออบเจ็กต์ 3 รายการ ได้แก่ operand0 = [3, 1], operand1 = [42, 50] และ operand2 = [-3.0, 1.1] และตัวเปรียบเทียบจะเปรียบเทียบเฉพาะค่าของ operand0 กับ "น้อยกว่า" ผลลัพธ์ของการเรียงลําดับคือ ([1, 3], [50, 42], [1.1, -3.0])

หากตั้งค่า is_stable เป็น "จริง" ระบบจะรับประกันการจัดเรียงที่เสถียร กล่าวคือ หากคอมพาเรเตอร์พิจารณาว่าองค์ประกอบมีค่าเท่ากัน ระบบจะเก็บลำดับสัมพัทธ์ของค่าที่เท่ากันไว้ องค์ประกอบ e1 และ e2 เท่ากันก็ต่อเมื่อ comparator(e1, e2) = comparator(e2, e1) = false โดยค่าเริ่มต้น ระบบจะตั้งค่า is_stable เป็นเท็จ

TopK

โปรดดูXlaBuilder::TopK

TopK จะค้นหาค่าและดัชนีขององค์ประกอบที่ใหญ่ที่สุดหรือเล็กที่สุด k รายการสำหรับมิติข้อมูลสุดท้ายของเทนเซอร์ที่ระบุ

TopK(operand, k, largest)

สำหรับเทนเซอร์อินพุต 1 มิติ (อาร์เรย์) จะค้นหาkรายการที่ใหญ่ที่สุดหรือเล็กที่สุด ในอาร์เรย์ และแสดงผลทูเพลตของอาร์เรย์ 2 รายการ (values, indices) ดังนั้น values[j] คือรายการที่ใหญ่ที่สุด/เล็กที่สุดลำดับที่ j ใน operand และดัชนีของรายการนี้คือ indices[j]

สำหรับเทนเซอร์อินพุตที่มีมิติข้อมูลมากกว่า 1 มิติ ให้คำนวณรายการ k อันดับแรกตามมิติข้อมูลสุดท้าย โดยเก็บมิติข้อมูล (แถว) อื่นๆ ทั้งหมดไว้ในเอาต์พุต ดังนั้น สำหรับออบเจ็กต์ที่มีรูปร่าง [A, B, ..., P, Q] โดยที่ Q >= k เอาต์พุตจะเป็น (values, indices) ซึ่งเป็นทูเปิลที่มีค่าดังนี้

values.shape = indices.shape = [A, B, ..., P, k]

หากองค์ประกอบ 2 รายการภายในแถวมีค่าเท่ากัน องค์ประกอบที่มีดัชนีต่ำกว่าจะปรากฏก่อน

สลับตำแหน่ง

โปรดดูการดำเนินการ tf.reshape ด้วย

Transpose(operand)

เปลี่ยนลําดับมิติข้อมูลออบเจ็กต์ด้วยการเปลี่ยนลําดับที่ระบุ ดังนี้ ∀ i . 0 ≤ i < number of dimensions ⇒ input_dimensions[permutation[i]] = output_dimensions[i]

ซึ่งเหมือนกับ Reshape(operand, permutation, Permute(permutation, operand.shape.dimensions))

TriangularSolve

โปรดดูXlaBuilder::TriangularSolve

แก้ระบบสมการเชิงเส้นที่มีเมทริกซ์สัมประสิทธิ์สามเหลี่ยมล่างหรือบนด้วยการแทนค่าไปข้างหน้าหรือข้างหลัง การกระจายไปตามมิติข้อมูลหลัก รูทีนนี้จะแก้ปัญหาระบบเมทริกซ์ op(a) * x = b หรือ x * op(a) = b รายการใดรายการหนึ่งสําหรับตัวแปร x โดยอิงตาม a และ b โดยที่ op(a) จะเป็น op(a) = a หรือ op(a) = Transpose(a) หรือ op(a) = Conj(Transpose(a))

TriangularSolve(a, b, left_side, lower, unit_diagonal, transpose_a)

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

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

Tuple

โปรดดูXlaBuilder::Tuple

มัดข้อมูลที่มีตัวแฮนเดิลข้อมูลจํานวนไม่คงที่ โดยแต่ละรายการมีรูปร่างเป็นของตัวเอง

ซึ่งคล้ายกับ std::tuple ใน 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);

คุณสามารถแยกโครงสร้าง (เข้าถึง) ของทูเปิลผ่านการดำเนินการ GetTupleElement

ในขณะที่

โปรดดูXlaBuilder::While

While(condition, body, init)

ดำเนินการ body ตามลำดับจนกว่า condition จะดำเนินการไม่สำเร็จ ซึ่งคล้ายกับ while loop ทั่วไปในภาษาอื่นๆ หลายภาษา ยกเว้นความแตกต่างและข้อจำกัดที่ระบุไว้ด้านล่าง

• โหนด While จะแสดงผลค่าประเภท T ซึ่งเป็นผลลัพธ์จากการดำเนินการ body ครั้งล่าสุด
• รูปร่างของประเภท T จะถูกกำหนดแบบคงที่และต้องเหมือนกันในทุกรอบ

ระบบจะเริ่มต้นพารามิเตอร์ T ของการคํานวณด้วยค่า init ในรอบแรก และจะอัปเดตเป็นผลลัพธ์ใหม่จาก body โดยอัตโนมัติในการวนซ้ำแต่ละครั้งต่อจากนี้

Use Case หลักอย่างหนึ่งของโหนด While คือการใช้การฝึกซ้ำในเครือข่ายประสาทเทียม รหัสจำลองแบบง่ายแสดงอยู่ด้านล่างพร้อมกราฟที่แสดงการคำนวณ รหัสจะอยู่ใน while_test.cc ประเภท T ในตัวอย่างนี้คือ Tuple ที่ประกอบด้วย int32 สำหรับจํานวนรอบ และ vector[10] สําหรับตัวสะสม สำหรับการวนซ้ำ 1, 000 ครั้ง ลูปจะเพิ่มเวกเตอร์คงที่ลงในตัวสะสมอย่างต่อเนื่อง

// Pseudocode for the computation.
init = {0, zero_vector[10]} // Tuple of int32 and float[10].
result = init;
while (result(0) < 1000) {
  iteration = result(0) + 1;
  new_vector = result(1) + constant_vector[10];
  result = {iteration, new_vector};
}