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

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

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

AfterAll

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

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

AfterAll(operands)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operands	XlaOp	จำนวนโทเค็นแปรผัน

AllGather

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

ดำเนินการเชื่อมต่อตัวจำลองต่างๆ

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์เพื่อเชื่อมโยงข้อมูลจำลอง
all_gather_dim	int64	มิติข้อมูลการต่อกัน
replica_groups	เวกเตอร์ของเวกเตอร์ของ int64	กลุ่มที่ใช้ ต่อเข้าด้วยกัน
channel_id	ไม่บังคับ int64	รหัสแชแนลที่ไม่บังคับ สำหรับการสื่อสารข้ามโมดูล

• 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	XlaOp	อาร์เรย์หรือแถวของอาร์เรย์ที่ไม่ว่างเปล่า เพื่อลดตัวจำลอง
computation	XlaComputation	การคํานวณการลด
replica_groups	เวกเตอร์ของเวกเตอร์ของ int64	กลุ่มที่จะมีการลด
channel_id	ไม่บังคับ int64	รหัสแชแนลที่ไม่บังคับ สำหรับการสื่อสารข้ามโมดูล

• เมื่อ operand เป็น Tuple ของอาร์เรย์ จะมีการดำเนินการแบบลดทั้งหมดในแต่ละองค์ประกอบของ Tuple
• 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 ตัว ค่าเอาต์พุตจากการคำนวณ op และการคำนวณผลรวมจะเป็น [4.0, 7.75] บนตัวจำลองทั้ง 2 รายการ หากอินพุตเป็น Tuple เอาต์พุตจะเป็น Tuple เช่นกัน

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

AllToAll

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

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

1. ระยะกระจาย ในแต่ละแกน ตัวถูกดำเนินการจะแบ่งออกเป็นจำนวนบล็อก split_count ตาม split_dimensions และบล็อกกระจัดกระจายไปยังแกนทั้งหมด เช่น ส่งบล็อก Ih ไปยังแกน Ith
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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์อินพุตมิติ n
split_dimension	int64	ค่าในช่วง [0, n) ที่มีชื่อมิติข้อมูลซึ่งตัวถูกดำเนินการถูกแยก
concat_dimension	int64	ค่าในช่วง [0, n) ที่มีชื่อมิติข้อมูลพร้อมกับบล็อกการแยกที่เชื่อมต่ออยู่
split_count	int64	จำนวนแกนที่เข้าร่วมการดำเนินการนี้ หาก replica_groups ว่างเปล่า ค่านี้ควรเป็นจำนวนของตัวจำลอง หรือควรเท่ากับจำนวนตัวจำลองในแต่ละกลุ่ม
replica_groups	ReplicaGroup เวกเตอร์	แต่ละกลุ่มจะมีรายการรหัสข้อมูลจำลอง

ด้านล่างแสดงตัวอย่างของ 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 ส่วนตามมิติข้อมูล 0 ดังนั้นแต่ละส่วนจะมีรูปร่าง f32[4,4] ทั้ง 4 ส่วนกระจายอยู่ในแกนทั้งหมด จากนั้นแกนแต่ละแกนจะเชื่อมส่วนที่ได้รับ ตามมิติข้อมูล 1 ตามลำดับของแกนหลัก 0-4 ดังนั้นเอาต์พุตในแต่ละแกน จะมีรูปร่าง f32[16,4]

BatchNormGrad

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

คำนวณการไล่ระดับสีของค่าปกติแบทช์

BatchNormGrad(operand, scale, mean, variance, grad_output, epsilon, feature_index)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์มิติ n ที่จะถูกทำให้เป็นมาตรฐาน (x)
scale	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ (\(\gamma\))
mean	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ (\(\mu\))
variance	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ (\(\sigma^2\))
grad_output	XlaOp	ผ่านการไล่ระดับสีไปยัง BatchNormTraining (\(\nabla y\))
epsilon	float	ค่า Epsilon (\(\epsilon\))
feature_index	int64	ดัชนีสำหรับมิติข้อมูลฟีเจอร์ใน operand

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

ประเภทเอาต์พุตจะเป็น Tuple ของแฮนเดิล 3 ตัว ได้แก่

เอาต์พุต	ประเภท	อรรถศาสตร์
grad_operand	XlaOp	การไล่ระดับสีตามอินพุต operand ($\nabla x$)
grad_scale	XlaOp	การไล่ระดับสีตามอินพุต scale ($\nabla \gamma$)
grad_offset	XlaOp	การไล่ระดับสีตามอินพุต offset($\nabla \beta$)

BatchNormInference

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

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

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์มิติ n ที่จะถูกทำให้เป็นมาตรฐาน
scale	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ
offset	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ
mean	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ
variance	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ
epsilon	float	ค่า Epsilon
feature_index	int64	ดัชนีสำหรับมิติข้อมูลฟีเจอร์ใน operand

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

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

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

BatchNormTraining

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

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

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์มิติ n ที่จะถูกทำให้เป็นมาตรฐาน (x)
scale	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ (\(\gamma\))
offset	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ (\(\beta\))
epsilon	float	ค่า Epsilon (\(\epsilon\))
feature_index	int64	ดัชนีสำหรับมิติข้อมูลฟีเจอร์ใน operand

สำหรับแต่ละองค์ประกอบในมิติข้อมูลของฟีเจอร์ (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 เพื่อหลีกเลี่ยงข้อผิดพลาดการหารด้วยศูนย์

ประเภทเอาต์พุตจะเป็น Tuple ของ XlaOp 3 รายการ ได้แก่

เอาต์พุต	ประเภท	อรรถศาสตร์
output	XlaOp	อาร์เรย์มิติ n ที่มีรูปทรงเดียวกับอินพุต operand (y)
batch_mean	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ (\(\mu\))
batch_var	XlaOp	อาร์เรย์มิติข้อมูล 1 รายการ (\(\sigma^2\))

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

BitcastConvertType

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

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

BitcastConvertType(operand, new_element_type)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ของประเภท T โดยมีความสว่าง D
new_element_type	PrimitiveType	ประเภท U

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

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

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

คำสั่ง HLO ของ BitcastConvert รองรับกรณีที่ขนาดขององค์ประกอบประเภทเอาต์พุต 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)

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

ประกาศ

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

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

Broadcast(operand, broadcast_sizes)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ที่จะทำซ้ำ
broadcast_sizes	ArraySlice<int64>	ขนาดของมิติข้อมูลใหม่

ระบบจะแทรกขนาดใหม่ทางด้านซ้าย เช่น หาก 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

BroadcastInDim

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

ขยายขนาดและอันดับของอาร์เรย์โดยการทำซ้ำข้อมูลในอาร์เรย์

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ที่จะทำซ้ำ
out_dim_size	ArraySlice<int64>	ขนาดของรูปร่างเป้าหมาย
broadcast_dimensions	ArraySlice<int64>	มิติข้อมูลใดในรูปร่างเป้าหมาย แต่ละมิติของรูปร่างตัวถูกดำเนินการสอดคล้องกับ

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

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

โทร

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

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

Call(computation, args...)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
computation	XlaComputation	การคำนวณประเภท T_0, T_1, ..., T_{N-1} -> S ที่มีพารามิเตอร์ N ประเภทที่กำหนดเอง
args	ลำดับ N XlaOp วินาที	อาร์กิวเมนต์ N ประเภทที่กำหนดเอง

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

ชูเลสกี

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

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

Cholesky(a, lower)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
a	XlaOp	อันดับ > 2 ของประเภทเชิงซ้อนหรือประเภทจุดลอยตัว
lower	bool	จะใช้สามเหลี่ยมบนหรือล่างของ a

หาก 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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
min	XlaOp	อาร์เรย์ประเภท T
operand	XlaOp	อาร์เรย์ประเภท T
max	XlaOp	อาร์เรย์ประเภท T

เมื่อมีตัวถูกดำเนินการและค่าต่ำสุดและสูงสุด ให้แสดงผลตัวถูกดำเนินการหากอยู่ภายในช่วงระหว่างค่าต่ำสุดและสูงสุด หรือแสดงผลค่าต่ำสุดหากตัวถูกดำเนินการต่ำกว่าช่วงนี้ หรือค่าสูงสุดหากตัวถูกดำเนินการอยู่เหนือช่วงนี้ นั่นคือ 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};

ยุบ

ดู XlaBuilder::Collapse และการดําเนินการ tf.reshape เพิ่มเติม

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

Collapse(operand, dimensions)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ประเภท T
dimensions	int64 เวกเตอร์	ส่วนย่อยของมิติข้อมูล T ที่เรียงต่อกันตามลำดับ

การยุบจะแทนที่ชุดย่อยของมิติข้อมูลของตัวถูกดำเนินการที่กำหนดด้วยมิติข้อมูลเดียว อาร์กิวเมนต์อินพุตเป็นอาร์เรย์ที่กำหนดเองของประเภท T และเวกเตอร์ค่าคงที่เวลาคอมไพล์ของดัชนีมิติข้อมูล ดัชนีมิติข้อมูลต้องเป็นรายการตามลำดับ (ตัวเลขมิติข้อมูลต่ำถึงสูง) ชุดย่อยของมิติข้อมูล T ที่อยู่ติดกัน ดังนั้น {0, 1, 2}, {0, 1} หรือ {1, 2} คือชุดมิติข้อมูลที่ถูกต้องทั้งหมด แต่ {1, 0} หรือ {0, 2} ไม่ใช่ มิติข้อมูลเหล่านี้จะถูกแทนที่ด้วยมิติข้อมูลใหม่เพียงรายการเดียว ในตำแหน่งเดียวกันในลำดับมิติข้อมูลกับมิติข้อมูลที่เข้ามาแทนที่ โดยมีขนาดมิติข้อมูลใหม่เท่ากับผลิตภัณฑ์ของขนาดมิติข้อมูลเดิม จำนวนมิติข้อมูลต่ำสุดใน dimensions คือมิติข้อมูลต่างๆ ที่ช้าที่สุด (หลักที่สุด) ใน Nest Loop ซึ่งยุบมิติข้อมูลเหล่านี้ และจำนวนมิติข้อมูลสูงสุดจะต่างกันเร็วที่สุด (น้อยที่สุด) โปรดดูโอเปอเรเตอร์ 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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์อินพุตมิติ n
source_target_pairs	<int64, int64> เวกเตอร์	รายการคู่ (source_replica_id, target_replica_id) สำหรับแต่ละคู่ ระบบจะส่งตัวถูกดำเนินการจากตัวจำลองต้นทางไปยังตัวจำลองเป้าหมาย

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

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

เชื่อมต่อ

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

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

Concatenate(operands..., dimension)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operands	ลำดับ N XlaOp	N อาร์เรย์ของประเภท T ที่มีมิติข้อมูล [L0, L1, ...] ต้องมี N >= 1
dimension	int64	ค่าในช่วง [0, N) ที่มีชื่อมิติข้อมูลที่จะเชื่อมต่อระหว่าง operands

มิติข้อมูลทั้งหมดต้องเหมือนกัน ยกเว้น 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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
pred	XlaOp	สเกลาร์ของประเภท PRED
true_operand	XlaOp	อาร์กิวเมนต์ของประเภท \(T_0\)
true_computation	XlaComputation	การคำนวณประเภท Xla \(T_0 \to S\)
false_operand	XlaOp	อาร์กิวเมนต์ของประเภท \(T_1\)
false_computation	XlaComputation	การคำนวณประเภท Xla \(T_1 \to S\)

เรียกใช้ 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_index	XlaOp	สเกลาร์ของประเภท S32
branch_computations	ลำดับ N XlaComputation	การคำนวณประเภท \(T_0 \to S , T_1 \to S , ..., T_{N-1} \to S\)
branch_operands	ลำดับ N XlaOp	อาร์กิวเมนต์ประเภท \(T_0 , T_1 , ..., T_{N-1}\)

ดำเนินการ branch_computations[branch_index] และแสดงผลลัพธ์ หาก branch_index เป็น S32 ซึ่ง < 0 หรือ >= N จะมีการดำเนินการ branch_computations[N-1] เป็น Branch เริ่มต้น

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

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

Conv. (Conv.)

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

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

ConvWithGeneralPadding (คอนโวลูชัน)

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

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
lhs	XlaOp	อันดับ n+2 อาร์เรย์ของอินพุต
rhs	XlaOp	อันดับอาร์เรย์ n+2 ของน้ำหนักเคอร์เนล
window_strides	ArraySlice<int64>	อาร์เรย์ n-d ของเคอร์เนล
padding	ArraySlice< pair<int64,int64>>	อาร์เรย์ n-d ของระยะห่างจากขอบ (ต่ำ, สูง)
lhs_dilation	ArraySlice<int64>	อาร์เรย์ปัจจัยการขยาย n-d lhs
rhs_dilation	ArraySlice<int64>	อาร์เรย์ปัจจัยการขยาย n-d rhs
feature_group_count	int64	จำนวนกลุ่มฟีเจอร์
batch_group_count	int64	จำนวนกลุ่มแบตช์

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

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

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

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

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

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

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

การขยายตัวของ RHS เรียกอีกอย่างว่าคอนโวลูชันที่โหดร้าย ดูรายละเอียดเพิ่มเติมได้ที่ tf.nn.atrous_conv2d การขยาย lhs เรียกอีกอย่างว่าคอนโวลูชันการสลับกัน (Transposed Convolution) ดูรายละเอียดเพิ่มเติมได้ที่ tf.nn.conv2d_transpose

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

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

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

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

หากต้องการอธิบายหน้าที่ของคอนโวลูชัน ให้พิจารณาคอนโวลูชัน 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 แต่ละรายการ คุณอาจคิดว่าเป็นคอนโวลูชันที่แยกกัน 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++ มิติข้อมูลต้องตรงกัน และ Conversion จะเป็นผู้พิจารณาตามองค์ประกอบ เช่น องค์ประกอบ s32 จะกลายเป็นองค์ประกอบ f32 ผ่านกิจวัตร Conversion s32 เป็น f32

ConvertElementType(operand, new_element_type)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ของประเภท T โดยมีความสว่าง D
new_element_type	PrimitiveType	ประเภท U

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

Conversion เช่น T=s32 เป็น U=f32 จะทำกิจวัตร Conversion แบบ Int-to-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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
target_name	string	ชื่อฟังก์ชัน คำสั่งการโทรจะได้รับการเผยแพร่ซึ่งกำหนดเป้าหมายไปยังชื่อสัญลักษณ์นี้
args	ลำดับ N XlaOp วินาที	อาร์กิวเมนต์ N ประเภทที่กำหนดเอง ซึ่งจะส่งไปยังฟังก์ชัน
shape	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];
  // ...
}

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

จุด

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

Dot(lhs, rhs)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
lhs	XlaOp	อาร์เรย์ประเภท T
rhs	XlaOp	อาร์เรย์ประเภท T

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

อินพุต	เอาต์พุต	อรรถศาสตร์
เวกเตอร์ [n] dot เวกเตอร์ [n]	สเกลาร์	ผลคูณเวกเตอร์แบบจุด
เมทริกซ์ [m x k] dot เวกเตอร์ [k]	เวกเตอร์ [m]	การคูณเวกเตอร์เมทริกซ์
เมทริกซ์ [m x k] dot เมทริกซ์ [k x n]	เมทริกซ์ [m x n]	การคูณเมทริกซ์-เมทริกซ์

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

DotGeneral

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

DotGeneral(lhs, rhs, dimension_numbers)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
lhs	XlaOp	อาร์เรย์ประเภท T
rhs	XlaOp	อาร์เรย์ประเภท T
dimension_numbers	DotDimensionNumbers	ตัวเลขมิติข้อมูลการทำสัญญาและแบบกลุ่ม

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

ช่อง DotDimensionNumbers	ประเภท	อรรถศาสตร์
lhs_contracting_dimensions	int64 ซ้ำ	หมายเลขมิติข้อมูลการทำสัญญา lhs รายการ
rhs_contracting_dimensions	int64 ซ้ำ	หมายเลขมิติข้อมูลการทำสัญญา rhs รายการ
lhs_batch_dimensions	int64 ซ้ำ	หมายเลขมิติข้อมูลกลุ่ม lhs รายการ
rhs_batch_dimensions	int64 ซ้ำ	หมายเลขมิติข้อมูลกลุ่ม 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} } }

อินพุต	เอาต์พุต	อรรถศาสตร์
[b0, m, k] dot [b0, k, n]	[b0, m, n]	แบทช์ แมทมูล
[b0, b1, m, k] dot [b0, b1, k, n]	[b0, b1, m, n]	แบทช์ แมทมูล

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

DynamicSlice

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

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

DynamicSlice(operand, start_indices, size_indices)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์มิติของประเภท T
start_indices	ลำดับ N XlaOp	รายการจำนวนเต็มสเกลาร์ N ที่มีดัชนีเริ่มต้นของสไลซ์สำหรับแต่ละมิติข้อมูล ค่าต้องมากกว่าหรือเท่ากับ 0
size_indices	ArraySlice<int64>	รายการจำนวนเต็ม N รายการที่มีขนาดชิ้นส่วนของแต่ละมิติข้อมูล แต่ละค่าต้องมากกว่า 0 เสมอ และเริ่มต้น + ขนาดต้องน้อยกว่าหรือเท่ากับขนาดของมิติข้อมูลเพื่อหลีกเลี่ยงการรวมขนาดมิติข้อมูลมอดูโล

ดัชนีส่วนแบ่งที่มีประสิทธิภาพจะคำนวณโดยใช้การเปลี่ยนรูปแบบต่อไปนี้สำหรับดัชนี 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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์มิติของประเภท T
update	XlaOp	อาร์เรย์มิติข้อมูล N ของประเภท T ที่มีการอัปเดตส่วนแบ่ง มิติข้อมูลแต่ละรายการของรูปร่างการอัปเดตต้องมากกว่า 0 และการเริ่มต้น + อัปเดตต้องน้อยกว่าหรือเท่ากับขนาดตัวถูกดำเนินการสำหรับแต่ละมิติข้อมูลเพื่อหลีกเลี่ยงการสร้างดัชนีการอัปเดตที่อยู่นอกขอบเขต
start_indices	ลำดับ N XlaOp	รายการจำนวนเต็มสเกลาร์ N ที่มีดัชนีเริ่มต้นของสไลซ์สำหรับแต่ละมิติข้อมูล ค่าต้องมากกว่าหรือเท่ากับ 0

ดัชนีส่วนแบ่งที่มีประสิทธิภาพจะคำนวณโดยใช้การเปลี่ยนรูปแบบต่อไปนี้สำหรับดัชนี 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 (การหาร), Rem (คงเหลือ), Max (สูงสุด), Min (ขั้นต่ำ), LogicalAnd (ตรรกะ AND) หรือ LogicalOr (ตรรกะ OR)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
lhs	XlaOp	ตัวถูกดำเนินการด้านซ้าย: อาร์เรย์ประเภท T
rhs	XlaOp	ตัวถูกดำเนินการด้านขวา: อาร์เรย์ประเภท T

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

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

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

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

Op(lhs, rhs, broadcast_dimensions)

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

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

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

ดูเพิ่มเติมที่ 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 < +NfN

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
lhs	XlaOp	ตัวถูกดำเนินการด้านซ้าย: อาร์เรย์ประเภท T
rhs	XlaOp	ตัวถูกดำเนินการด้านขวา: อาร์เรย์ประเภท T

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

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

Op(lhs, rhs, broadcast_dimensions)

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

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

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

XlaBuilder รองรับฟังก์ชันเอกพจน์ที่อิงตามองค์ประกอบดังต่อไปนี้

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

Ceil(operand) CEil ตามองค์ประกอบ x -> ⌈x⌉

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

Exp(operand) เลขชี้กำลังปกติของธาตุ x -> e^x

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

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

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

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

LogicalNot(operand) ตรรกะตามองค์ประกอบ ไม่ใช่ x -> !(x)

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

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

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

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

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

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

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

Tanh(operand) ไฮเปอร์โบลิกแทนเจนต์แบบ Element-wise x -> tanh(x)

Round(operand) การปัดเศษตามองค์ประกอบ ให้เสมอกันที่มีค่าเท่ากับ 0

RoundNearestEven(operand) การปัดเศษตามองค์ประกอบ โดยสัมพันธ์กับเลขคู่ที่ใกล้เคียงที่สุด

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	ตัวถูกดำเนินการของฟังก์ชัน

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

Fft

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

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ที่เรากําลังเปลี่ยนรูปแบบฟูริเย
fft_type	FftType	โปรดดูตารางด้านล่าง
fft_length	ArraySlice<int64>	ความยาวของโดเมนในแกนที่เปลี่ยนรูปแบบ จำเป็นต้องใช้ค่านี้โดยเฉพาะอย่างยิ่งสำหรับ IRFFT ในการปรับขนาดแกนด้านในสุดด้านขวา เนื่องจาก RFFT(fft_length=[16]) มีรูปร่างเอาต์พุตเหมือนกับ RFFT(fft_length=[17])

FftType	อรรถศาสตร์
FFT	ส่งต่อ FFT แบบซับซ้อนไปซับซ้อน รูปร่างไม่มีการเปลี่ยนแปลง
IFFT	FFT แบบผกผันเชิงซ้อนไปซับซ้อน รูปร่างไม่มีการเปลี่ยนแปลง
RFFT	ส่งต่อ FFT แบบจริงที่ไปซับซ้อน ลดรูปร่างของแกนด้านในสุดเป็น fft_length[-1] // 2 + 1 หาก fft_length[-1] เป็นค่าที่ไม่ใช่ 0 โดยละเว้นส่วนสังยุคย้อนกลับของสัญญาณที่มีการแปลงนอกเหนือจากความถี่ Nyquist
IRFFT	FFT แบบผกผันจริงไปจนถึงความซับซ้อน (กล่าวคือ ใช้ค่าที่ซับซ้อน แสดงผลจริง) รูปร่างของแกนด้านในสุดจะขยายเป็น fft_length[-1] หาก fft_length[-1] เป็นค่าที่ไม่ใช่ 0 โดยอนุมานส่วนของสัญญาณที่มีการเปลี่ยนรูปแบบนอกเหนือจากความถี่ไนควิสต์จากสังยุคย้อนกลับของรายการ 1 เป็น fft_length[-1] // 2 + 1

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

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

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

CPU FFT ได้รับการสนับสนุนโดย TensorFFT ของ Eigen GPU FFT ใช้ cuFFT

รวบรวม

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

อรรถศาสตร์ทั่วไป

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

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ที่เรารวบรวม
start_indices	XlaOp	อาร์เรย์ที่มีดัชนีเริ่มต้นของส่วนที่เรารวบรวม
index_vector_dim	int64	มิติข้อมูลใน start_indices ที่ "มี" ดัชนีเริ่มต้น โปรดดูคำอธิบายโดยละเอียดด้านล่าง
offset_dims	ArraySlice<int64>	ชุดของขนาดในรูปร่างเอาต์พุตที่ออฟเซ็ตเป็นอาร์เรย์ที่แบ่งตามตัวถูกดำเนินการ
slice_sizes	ArraySlice<int64>	slice_sizes[i] คือขอบเขตของสไลซ์ในมิติข้อมูล i
collapsed_slice_dims	ArraySlice<int64>	ชุดของมิติข้อมูลในแต่ละสไลซ์ที่ยุบหายไป มิติข้อมูลเหล่านี้ต้องมีขนาด 1
start_index_map	ArraySlice<int64>	แผนที่ที่อธิบายวิธีจับคู่ดัชนีใน start_indices กับดัชนีกฎหมายลงในตัวถูกดำเนินการ
indices_are_sorted	bool	ดูว่าผู้โทรจัดเรียงดัชนีแล้วหรือไม่

เราติดป้ายกำกับมิติข้อมูลในอาร์เรย์เอาต์พุตที่ไม่ใช่ 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 บาง 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[รวม(G, i)] โดยที่ รวม(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] หาก 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]] หาก k < offset_dims.size (remapped_offset_dims กำหนดไว้ด้านล่าง)

   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 อย่างไรก็ดี ก่อนที่จะใช้เป็นดัชนีในอาร์เรย์อินพุต 1 พารามิเตอร์จะถูกขยายตาม "1 รวบรวมการแมปดัชนี" (start_index_map ใน คำอธิบายอย่างเป็นทางการ) และ "การแมปออฟเซต" (remapped_offset_dims ในคำอธิบายอย่างเป็นทางการ) ลงใน [X,0] และ [0,O0] ตามลำดับ โดยเพิ่มเป็น [X,O0] ตามลำดับ กล่าวอีกนัยหนึ่งคือ [X,O/₀] กล่าวคือ [_{}{/2] ดัชนี}[_}{/[G] ดัชนี [_}{/2]G0000OGG11GatherIndicestf.gather_nd

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

GetDimensionSize

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

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

GetDimensionSize(operand, dimension)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์อินพุตมิติ n
dimension	int64	ค่าในช่วง [0, n) ที่ระบุมิติข้อมูล

SetDimensionSize

ดูเพิ่มเติมที่ XlaBuilder::SetDimensionSize

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

SetDimensionSize(operand, size, dimension)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	n อาร์เรย์อินพุตมิติ
size	XlaOp	int32 แสดงถึงขนาดแบบไดนามิกของรันไทม์
dimension	int64	ค่าในช่วง [0, n) ที่ระบุมิติข้อมูล

ส่งต่อตัวถูกดำเนินการด้วยมิติข้อมูลแบบไดนามิกที่มีการติดตามโดยคอมไพเลอร์

การดำเนินการลดดาวน์สตรีมจะไม่สนใจค่าที่เพิ่มเข้ามา

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

จัดทำดัชนีเป็น Tuple ที่มีค่าคงที่เวลาคอมไพล์

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

ค่านี้เทียบเคียงกับ 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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
shape	Shape	รูปร่างของข้อมูลที่อ่านจากอินเทอร์เฟซในฟีด ต้องตั้งช่องเลย์เอาต์ของรูปร่างให้ตรงกับเลย์เอาต์ของข้อมูลที่ส่งไปยังอุปกรณ์ มิเช่นนั้นจะไม่มีการกำหนดลักษณะการทำงาน

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

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

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

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

Iota

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

Iota(shape, iota_dimension)

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
shape	Shape	รูปร่างของอาร์เรย์ที่สร้างโดย Iota()
iota_dimension	int64	มิติข้อมูลที่จะเพิ่มขึ้นตามไปด้วย

เช่น 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 XlaOp วินาที	N อาร์เรย์ของประเภท T0..T{N-1}
computation	XlaComputation	การคำนวณประเภท T_0, T_1, .., T_{N + M -1} -> S ที่มีพารามิเตอร์ N ประเภท T และ M ในประเภทที่กำหนดเอง
dimensions	อาร์เรย์ int64	อาร์เรย์ของขนาดแผนที่

ใช้ฟังก์ชันสเกลาร์กับอาร์เรย์ 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	XlaOp	อาร์เรย์ประเภท T
padding_value	XlaOp	สเกลาร์ของประเภท T เพื่อเติมระยะห่างจากขอบที่เพิ่มเข้ามา
padding_config	PaddingConfig	ระยะห่างจากขอบทั้ง 2 ด้าน (ต่ำ, สูง) และระหว่างองค์ประกอบของมิติข้อมูลแต่ละรายการ

ขยายอาร์เรย์ 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) และค่าระยะห่างจากขอบภายในเป็น 0 ทั้งหมด ภาพด้านล่างแสดงตัวอย่างของค่า edge_padding และ interior_padding ที่แตกต่างกันสำหรับอาร์เรย์ 2 มิติ

รับ

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

Recv(shape, channel_handle)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
shape	Shape	รูปร่างของข้อมูลที่จะรับ
channel_handle	ChannelHandle	ตัวระบุที่ไม่ซ้ำกันสำหรับคู่การส่ง/รับแต่ละคู่

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

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

Recv(const Shape& shape, int64 channel_id)

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

RecvDone(HloInstruction context)

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

ลด (Reduce)

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

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

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operands	ลำดับของ N XlaOp	N อาร์เรย์ของประเภท T_0, ..., T_{N-1}
init_values	ลำดับของ N XlaOp	สเกลาร์ N ประเภท T_0, ..., T_{N-1}
computation	XlaComputation	การคำนวณประเภท T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1})
dimensions	อาร์เรย์ int64	อาร์เรย์ของมิติข้อมูลที่ไม่เรียงลำดับที่จะลด

โดยที่

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

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

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

ตัวอย่าง

เมื่อลดขนาดลงหนึ่งมิติข้อมูลในอาร์เรย์ 1D เดียวที่มีค่า [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 rank 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 ด้วยฟังก์ชัน "เพิ่ม"

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

สำหรับตัวอย่างที่ซับซ้อนยิ่งขึ้น นี่คืออาร์เรย์ 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

วาเรียดิก Reduce (Variadic Reduce)

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

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

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

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

สำหรับอาร์เรย์อินพุต 1-D 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) จะทำซ้ำในอาร์เรย์ต่างๆ แล้วแสดงผล Tuple ที่มีค่าสูงสุดและดัชนีที่ตรงกัน

ReducePrecision

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

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

ReducePrecision(operand, mantissa_bits, exponent_bits)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ของประเภทจุดลอยตัว T
exponent_bits	int32	จำนวนบิตของเลขชี้กำลังในรูปแบบที่มีความแม่นยำต่ำ
mantissa_bits	int32	จำนวนบิตของตั๊กแตนในรูปแบบความแม่นยำต่ำ

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

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

ReduceScatter

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

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

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์หรือ Tuple ของอาร์เรย์ที่ไม่ว่างเปล่าที่จะลดตัวจำลอง
computation	XlaComputation	การคํานวณการลด
scatter_dimension	int64	มิติข้อมูลที่จะกระจาย
shard_count	int64	จำนวนบล็อกที่จะแยก scatter_dimension
replica_groups	เวกเตอร์ของเวกเตอร์ของ int64	กลุ่มที่มีการลด
channel_id	ไม่บังคับ int64	รหัสแชแนลที่ไม่บังคับสำหรับการสื่อสารข้ามโมดูล

• เมื่อ operand เป็น Tuple ของอาร์เรย์ ระบบจะใช้ลดการกระจายกับแต่ละองค์ประกอบของ Tuple
• 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 ตัวตามลำดับ ค่าเอาต์พุตจาก op นี้โดยที่ scatter_dim คือ 0 จะเป็น [4.0] สำหรับตัวจำลองแรก และ [7.5] สำหรับตัวจำลองที่ 2

ReduceWindow

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

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

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operands	N XlaOps	ลำดับของอาร์เรย์หลายมิติ N ของประเภท T_0,..., T_{N-1} โดยแต่ละอาร์เรย์แสดงพื้นที่ฐานที่มีการวางหน้าต่าง
init_values	N XlaOps	ค่าเริ่มต้นของ N สำหรับการลด 1 ค่าต่อตัวถูกดำเนินการ N แต่ละค่า ดูรายละเอียดได้ที่ลด
computation	XlaComputation	ฟังก์ชันการลดประเภท T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1}) ที่จะใช้กับองค์ประกอบในแต่ละหน้าต่างของตัวถูกดำเนินการอินพุตทั้งหมด
window_dimensions	ArraySlice<int64>	อาร์เรย์ของจำนวนเต็มสำหรับค่ามิติข้อมูลหน้าต่าง
window_strides	ArraySlice<int64>	อาร์เรย์ของจำนวนเต็มสำหรับค่า Window Stride
base_dilations	ArraySlice<int64>	อาร์เรย์ของจำนวนเต็มสำหรับค่าการขยายฐาน
window_dilations	ArraySlice<int64>	อาร์เรย์ของจำนวนเต็มสำหรับค่าการขยายหน้าต่าง
padding	Padding	ประเภทระยะห่างจากขอบสำหรับหน้าต่าง (แพดดิง::kSame ซึ่งทำให้มีรูปร่างเอาต์พุตเดียวกันกับอินพุตหากก้าวเป็น 1 หรือ Padding::kValid ซึ่งไม่มีระยะห่างจากขอบและ "หยุด" หน้าต่างเมื่อปรับขนาดไม่พอดี)

โดยที่

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

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

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ประเภท T
dimensions	int64 เวกเตอร์	ลำดับการยุบมิติข้อมูล
new_sizes	int64 เวกเตอร์	เวกเตอร์ของขนาดของขนาดใหม่

โดยหลักการแล้ว จะต้องปรับรูปร่างของอาร์เรย์ให้เป็นเวกเตอร์ 1 มิติของค่าข้อมูลก่อน แล้วจึงปรับแต่งเวกเตอร์นี้เป็นรูปร่างใหม่ อาร์กิวเมนต์อินพุตคืออาร์เรย์ที่กำหนดเองของประเภท T ซึ่งเป็นเวกเตอร์คงที่เวลาคอมไพล์ของดัชนีมิติข้อมูล และเวกเตอร์คงที่เวลาคอมไพล์ของขนาดมิติข้อมูลสำหรับผลลัพธ์ หากมีค่าในเวกเตอร์ dimension ค่าจะต้องเป็นการเรียงสับเปลี่ยนของมิติข้อมูล T ทั้งหมด ค่าเริ่มต้นหากไม่ได้กำหนดคือ {0, ..., rank - 1} ลำดับของมิติข้อมูลใน dimensions เริ่มจากมิติข้อมูลที่เปลี่ยนแปลงช้าที่สุด (หลัก) ไปจนถึงมิติข้อมูลที่เปลี่ยนแปลงเร็วที่สุด (น้อยที่สุด) ใน Nest Loop ซึ่งจะยุบอาร์เรย์อินพุตเป็นมิติข้อมูลเดียว เวกเตอร์ new_sizes จะกำหนดขนาดของอาร์เรย์เอาต์พุต ค่าที่ดัชนี 0 ใน new_sizes คือขนาดของมิติข้อมูล 0 ค่าในดัชนี 1 คือขนาดของมิติข้อมูล 1 และต่อไปเรื่อยๆ ผลิตภัณฑ์ของมิติข้อมูล new_size ต้องเท่ากับผลคูณของขนาดตัวถูกดำเนินการ เมื่อปรับแต่งอาร์เรย์ที่ยุบเป็นอาร์เรย์หลายมิติที่ new_sizes กำหนด มิติข้อมูลใน new_sizes จะเรียงลำดับจากต่างกันช้าที่สุด (ใหญ่ที่สุด) ไปจนถึงแปรผันเร็วที่สุด (น้อยที่สุด)

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

In-order collapse:
let v012_24 = Reshape(v, {0,1,2}, {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, {0,1,2}, {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} };

Out-of-order collapse:
let v021_24 = Reshape(v, {1,2,0}, {24});
then v012_24 == f32[24]  {10, 20, 30, 40, 11, 21, 31, 41, 12, 22, 32, 42,
                          15, 25, 35, 45, 16, 26, 36, 46, 17, 27, 37, 47};

let v021_83 = Reshape(v, {1,2,0}, {8,3});
then v021_83 == f32[8x3] { {10, 20, 30}, {40, 11, 21},
                          {31, 41, 12}, {22, 32, 42},
                          {15, 25, 35}, {45, 16, 26},
                          {36, 46, 17}, {27, 37, 47} };


let v021_262 = Reshape(v, {1,2,0}, {2,6,2});
then v021_262 == f32[2x6x2] { { {10, 20}, {30, 40},
                              {11, 21}, {31, 41},
                              {12, 22}, {32, 42} },
                             { {15, 25}, {35, 45},
                              {16, 26}, {36, 46},
                              {17, 27}, {37, 47} } };

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

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

Rev (ย้อนกลับ)

ดูเพิ่มเติมที่ XlaBuilder::Rev

Rev(operand, dimensions)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ประเภท T
dimensions	ArraySlice<int64>	มิติข้อมูลที่จะกลับด้าน

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

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

RngNormal

ดูเพิ่มเติมที่ XlaBuilder::RngNormal

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

RngNormal(mu, sigma, shape)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
mu	XlaOp	สเกลาร์ของประเภท T ที่ระบุค่าเฉลี่ยของจำนวนที่สร้างขึ้น
sigma	XlaOp	สเกลาร์ของประเภท T ที่ระบุส่วนเบี่ยงเบนมาตรฐานของประเภทที่สร้างขึ้น
shape	Shape	รูปร่างเอาต์พุตของประเภท T

RngUniform

ดูเพิ่มเติมที่ XlaBuilder::RngUniform

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

RngUniform(a, b, shape)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
a	XlaOp	สเกลาร์ของประเภท T ที่ระบุขีดจำกัดต่ำสุดของช่วงเวลา
b	XlaOp	สเกลาร์ของประเภท T ที่ระบุขีดจำกัดบนของช่วง
shape	Shape	รูปร่างเอาต์พุตของประเภท T

RngBitGenerator

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

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

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

RngBitGenerator(algorithm, key, shape)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
algorithm	RandomAlgorithm	อัลกอริทึม PRNG ที่จะใช้
initial_state	XlaOp	สถานะเริ่มต้นสำหรับอัลกอริทึม PRNG
shape	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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operands	ลำดับของ N XlaOp	N อาร์เรย์ของประเภท T_0, ..., T_N ที่จะกระจายไป
scatter_indices	XlaOp	อาร์เรย์ที่มีดัชนีเริ่มต้นของส่วนที่ต้องกระจาย
updates	ลำดับของ N XlaOp	N อาร์เรย์ของประเภท T_0, ..., T_N updates[i] มีค่าที่ต้องใช้สําหรับการกระจาย operands[i]
update_computation	XlaComputation	การคำนวณที่จะใช้สำหรับการรวมค่าที่มีอยู่ในอาร์เรย์อินพุตและการอัปเดตระหว่างการกระจาย การคำนวณนี้ควรเป็นประเภท T_0, ..., T_N, T_0, ..., T_N -> Collate(T_0, ..., T_N)
index_vector_dim	int64	มิติข้อมูลใน scatter_indices ที่มีดัชนีเริ่มต้น
update_window_dims	ArraySlice<int64>	ชุดของขนาดในรูปร่าง updates ที่เป็นขนาดหน้าต่าง
inserted_window_dims	ArraySlice<int64>	ชุดขนาดหน้าต่างที่ต้องแทรกในรูปร่าง updates
scatter_dims_to_operand_dims	ArraySlice<int64>	มิติข้อมูลแมปจากดัชนีกระจายไปยังพื้นที่ดัชนีตัวถูกดำเนินการ ระบบตีความอาร์เรย์นี้เป็นการจับคู่ i กับ scatter_dims_to_operand_dims[i] โดยจะต้องเป็นแบบ 1 ต่อ 1 และทั้งหมด
indices_are_sorted	bool	ดูว่าผู้โทรจัดเรียงดัชนีแล้วหรือไม่
unique_indices	bool	ผู้โทรรับประกันว่าดัชนีจะไม่ซ้ำกันหรือไม่

โดยที่

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

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

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

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

• อาร์เรย์ 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] และค่าต้องอยู่ในช่วง [0, operand.rank)

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

1. ให้ G = { U[k] สำหรับ k ใน update_scatter_dims } ใช้ G เพื่อค้นหาเวกเตอร์ดัชนี S ในอาร์เรย์ scatter_indices ที่ S[i] = scatter_indices[รวม(G, i)] โดยที่ "รวม" (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] หาก 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 เป็นฟังก์ชันแบบโมโนโทนที่มีโดเมน [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 โดยที่ + เป็นการบวกตามองค์ประกอบ

กล่าวโดยสรุป การกระจายข้อมูลสามารถกำหนดได้ดังนี้

• เริ่มต้น 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 จะถือว่าผู้ใช้จัดเรียง start_indices (ตามลำดับจากน้อยไปมาก)start_index_map หากไม่ได้ใช้ ความหมายคือ "การติดตั้งใช้งาน"

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

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

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

เลือก

ดูเพิ่มเติมที่ XlaBuilder::Select

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

Select(pred, on_true, on_false)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
pred	XlaOp	อาร์เรย์ของประเภท PRED
on_true	XlaOp	อาร์เรย์ประเภท T
on_false	XlaOp	อาร์เรย์ประเภท T

อาร์เรย์ 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};

ตัวอย่างที่มีสเกลาร์ 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};

รองรับการเลือกระหว่าง Tuple Tuple ถือเป็นประเภทสเกลาร์สำหรับจุดประสงค์นี้ หาก on_true และ on_false เป็น 2 เท่า (ซึ่งต้องมีรูปร่างเหมือนกัน) 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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์ประเภท T ที่หน้าต่างเลื่อน
select	XlaComputation	การคำนวณไบนารีประเภท T, T -> PRED เพื่อใช้กับองค์ประกอบทั้งหมดในแต่ละหน้าต่าง แสดงผล true หากเลือกพารามิเตอร์แรก และแสดงผล false หากเลือกพารามิเตอร์ที่ 2
window_dimensions	ArraySlice<int64>	อาร์เรย์ของจำนวนเต็มสำหรับค่ามิติข้อมูลหน้าต่าง
window_strides	ArraySlice<int64>	อาร์เรย์ของจำนวนเต็มสำหรับค่า Window Stride
padding	Padding	ประเภทระยะห่างจากขอบสำหรับหน้าต่าง (แพดดิง::kSame หรือ Padding::kValid)
source	XlaOp	อาร์เรย์ประเภท T ที่มีค่ากระจาย
init_value	XlaOp	ค่าสเกลาร์ของประเภท T สำหรับค่าเริ่มต้นของอาร์เรย์เอาต์พุต
scatter	XlaComputation	การคํานวณไบนารีประเภท T, T -> T เพื่อใช้องค์ประกอบต้นทางแบบกระจายแต่ละรายการกับองค์ประกอบปลายทาง

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

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

ส่ง

ดูเพิ่มเติมที่ XlaBuilder::Send

Send(operand, channel_handle)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	ข้อมูลที่จะส่ง (อาร์เรย์ประเภท T)
channel_handle	ChannelHandle	ตัวระบุที่ไม่ซ้ำกันสำหรับคู่การส่ง/รับแต่ละคู่

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

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

Send(HloInstruction operand, int64 channel_id)

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

SendDone(HloInstruction context)

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

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

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

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

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

Slice

ดูเพิ่มเติมที่ XlaBuilder::Slice

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

Slice(operand, start_indices, limit_indices, strides)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	อาร์เรย์มิติของประเภท T
start_indices	ArraySlice<int64>	รายการจำนวนเต็ม N ที่มีดัชนีเริ่มต้นของสไลซ์สำหรับแต่ละมิติข้อมูล ค่าต้องมากกว่าหรือเท่ากับ 0
limit_indices	ArraySlice<int64>	รายการจำนวนเต็ม N ที่มีดัชนีสิ้นสุด (แยกเฉพาะ) สำหรับสไลซ์ของแต่ละมิติข้อมูล แต่ละค่าต้องมากกว่าหรือเท่ากับค่า start_indices ที่เกี่ยวข้องสําหรับมิติข้อมูล และน้อยกว่าหรือเท่ากับขนาดของมิติข้อมูล
strides	ArraySlice<int64>	รายการจำนวนเต็ม N ที่ตัดสินอัตราก้าวของอินพุตของส่วนแบ่ง สไลซ์จะเลือกองค์ประกอบ strides[d] ทุกรายการในมิติข้อมูล d

ตัวอย่าง 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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operands	ArraySlice<XlaOp>	ตัวถูกดำเนินการที่จะจัดเรียง
comparator	XlaComputation	การคำนวณของตัวเปรียบเทียบที่จะใช้
dimension	int64	มิติข้อมูลที่ต้องการจัดเรียง
is_stable	bool	ควรใช้การจัดเรียงที่เสถียรหรือไม่

หากระบุตัวถูกดำเนินการรายการเดียว:

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

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

หากมีตัวถูกดำเนินการ n > 1 อยู่

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

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

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

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

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

สลับ

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

Transpose(operand)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
operand	XlaOp	ตัวถูกดำเนินการที่จะสลับแกน
permutation	ArraySlice<int64>	วิธีลดมิติข้อมูล

เรียงสับเปลี่ยนมิติข้อมูลโอเปอแรนด์ด้วยการเรียงสับเปลี่ยนที่กำหนด ดังนั้น ∀ i . 0 ≤ i < rank ⇒ input_dimensions[permutation[i]] = output_dimensions[i]

ซึ่งจะเหมือนกับ Reshape(โอเปอเรเตอร์, การเรียงสับเปลี่ยน, 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	XlaOp	อันดับ > 2 ของประเภทเชิงซ้อนหรือประเภทจุดลอยตัวที่มีรูปร่าง [..., M, M]
b	XlaOp	อาร์เรย์อันดับ > 2 ของประเภทเดียวกันที่มีรูปร่าง [..., M, K] หาก left_side เป็น "จริง" [..., K, M] หากไม่ใช่
left_side	bool	ระบุว่าจะแก้ระบบในรูปแบบ op(a) * x = b (true) หรือ x * op(a) = b (false)
lower	bool	จะใช้สามเหลี่ยมบนหรือล่างของ a
unit_diagonal	bool	หากเป็น true ระบบจะถือว่าองค์ประกอบแนวทแยงมุมของ a เป็น 1 และไม่มีการเข้าถึง
transpose_a	Transpose	จะใช้ a ตามที่เป็นอยู่ สลับตำแหน่งหรือสลับสังยุค

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

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

ลายนูน

ดูเพิ่มเติมที่ 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)

อาร์กิวเมนต์	ประเภท	อรรถศาสตร์
condition	XlaComputation	XlaComputation ของประเภท T -> PRED ซึ่งกำหนดเงื่อนไขการสิ้นสุดของลูป
body	XlaComputation	XlaComputation ของประเภท T -> T ซึ่งกำหนดเนื้อหาของลูป
init	T	ค่าเริ่มต้นสำหรับพารามิเตอร์ของ condition และ body

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

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

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

กรณีการใช้งานหลักอย่างหนึ่งของโหนด 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};
}