Semantik operasi

Berikut ini menjelaskan semantik operasi yang ditentukan di antarmuka XlaBuilder. Biasanya, operasi ini memetakan one-to-one ke operasi yang ditentukan dalam antarmuka RPC di xla_data.proto.

Catatan tentang terminologi: jenis data umum yang ditangani XLA adalah array berdimensi N yang menyimpan elemen dari beberapa jenis seragam (seperti float 32-bit). Di seluruh dokumentasi, array digunakan untuk menunjukkan array dimensi arbitrer. Untuk memudahkan, kasus khusus memiliki nama yang lebih spesifik dan dikenal; misalnya, vektor adalah array 1 dimensi dan matriks adalah array 2 dimensi.

AfterAll

Lihat juga XlaBuilder::AfterAll.

AfterAll mengambil jumlah token variabel dan menghasilkan satu token. Token adalah jenis primitif yang dapat di-thread di antara operasi yang menghasilkan efek samping untuk menerapkan pengurutan. AfterAll dapat digunakan sebagai gabungan token untuk mengurutkan operasi setelah operasi kumpulan.

AfterAll(operands)

Argumen	Jenis	Semantik
operands	XlaOp	jumlah token variabel

AllGather

Lihat juga XlaBuilder::AllGather.

Melakukan penyambungan di seluruh replika.

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

Argumen	Jenis	Semantik
operand	XlaOp	Array untuk digabungkan di seluruh replika
all_gather_dim	int64	Dimensi penyambungan
replica_groups	vektor vektor int64	Grup yang melakukan penyambungan
channel_id	int64 opsional	ID saluran opsional untuk komunikasi lintas modul

• replica_groups adalah daftar grup replika tempat penyambungan dilakukan (ID replika untuk replika saat ini dapat diambil menggunakan ReplicaId). Urutan replika di setiap grup menentukan urutan inputnya dalam hasil. replica_groups harus kosong (dalam hal ini, semua replika termasuk dalam satu grup, yang diurutkan dari 0 hingga N - 1), atau berisi jumlah elemen yang sama dengan jumlah replika. Misalnya, replica_groups = {0, 2}, {1, 3} melakukan penggabungan antara replika 0 dan 2, serta 1 dan 3.
• shard_count adalah ukuran setiap grup replika. Kita memerlukannya jika replica_groups kosong.
• channel_id digunakan untuk komunikasi lintas modul: hanya operasi all-gather dengan channel_id yang sama yang dapat saling berkomunikasi.

Bentuk output adalah bentuk input dengan all_gather_dim yang dibuat shard_count kali lebih besar. Misalnya, jika ada dua replika dan operand memiliki nilai [1.0, 2.5] dan [3.0, 5.25] masing-masing pada dua replika, maka nilai output dari operasi ini dengan all_gather_dim adalah 0 akan menjadi [1.0, 2.5, 3.0, 5.25] di kedua replika.

AllReduce

Lihat juga XlaBuilder::AllReduce.

Melakukan komputasi kustom di seluruh replika.

AllReduce(operand, computation, replica_group_ids, channel_id)

Argumen	Jenis	Semantik
operand	XlaOp	Array atau tuple array yang tidak kosong untuk dikurangi di seluruh replika
computation	XlaComputation	Penghitungan pengurangan
replica_groups	vektor vektor int64	Grup tempat pengurangan dilakukan
channel_id	int64 opsional	ID saluran opsional untuk komunikasi lintas modul

• Jika operand adalah tuple array, semua pengurangan dilakukan pada setiap elemen tuple.
• replica_groups adalah daftar grup replika tempat pengurangan dilakukan (ID replika untuk replika saat ini dapat diambil menggunakan ReplicaId). replica_groups harus kosong (dalam hal ini, semua replika termasuk dalam satu grup), atau berisi jumlah elemen yang sama dengan jumlah replika. Misalnya, replica_groups = {0, 2}, {1, 3} melakukan pengurangan antara replika 0 dan 2, serta 1 dan 3.
• channel_id digunakan untuk komunikasi lintas modul: hanya operasi all-reduce dengan channel_id yang sama yang dapat saling berkomunikasi.

Bentuk output sama dengan bentuk input. Misalnya, jika ada dua replika dan operand memiliki nilai [1.0, 2.5] dan [3.0, 5.25] masing-masing pada dua replika, nilai output dari op ini dan komputasi penjumlahan akan menjadi [4.0, 7.75] di kedua replika. Jika inputnya adalah tuple, outputnya juga berupa tuple.

Menghitung hasil AllReduce memerlukan satu input dari setiap replika, jadi jika satu replika mengeksekusi node AllReduce lebih sering daripada replika lainnya, replika terdahulu akan menunggu selamanya. Karena semua replika menjalankan program yang sama, tidak ada banyak cara untuk melakukannya, tetapi hal ini dapat terjadi jika kondisi while loop bergantung pada data dari infeed dan data yang dimasukkan menyebabkan while loop melakukan iterasi lebih banyak pada satu replika daripada replika lainnya.

AllToAll

Lihat juga XlaBuilder::AllToAll.

AllToAll adalah operasi kolektif yang mengirimkan data dari semua core ke semua core. Proses ini memiliki dua fase:

1. Fase penyebaran. Pada setiap core, operand dibagi menjadi split_count jumlah blok di sepanjang split_dimensions, dan blok tersebut tersebar ke semua core, misalnya, blok ke-i dikirim ke inti ke-i.
2. Fase pengumpulan. Setiap core menyambungkan blok yang diterima di sepanjang concat_dimension.

Core yang berpartisipasi dapat dikonfigurasi dengan:

• replica_groups: setiap ReplicaGroup berisi daftar ID replika yang berpartisipasi dalam komputasi (ID replika untuk replika saat ini dapat diambil menggunakan ReplicaId). AllToAll akan diterapkan dalam subgrup dalam urutan yang ditentukan. Misalnya, replica_groups = { {1,2,3}, {4,5,0} } berarti bahwa AllToAll akan diterapkan dalam replika {1, 2, 3}, dan dalam fase pengumpulan, dan blok yang diterima akan digabungkan dalam urutan 1, 2, 3 yang sama. Kemudian, AllToAll lain akan diterapkan dalam replika 4, 5, 0, dan urutan penyambungannya juga 4, 5, 0. Jika replica_groups kosong, semua replika akan termasuk dalam satu grup, dalam urutan penyambungan tampilannya.

Prasyarat:

• Ukuran dimensi operand pada split_dimension dapat dibagi dengan split_count.
• Bentuk operand bukan tuple.

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

Argumen	Jenis	Semantik
operand	XlaOp	Array input dimensi n
split_dimension	int64	Nilai dalam interval [0, n) yang memberi nama dimensi sepanjang operand dibagi
concat_dimension	int64	Nilai dalam interval [0, n) yang memberi nama dimensi beserta blok pemisahan digabungkan
split_count	int64	Jumlah core yang berpartisipasi dalam operasi ini. Jika replica_groups kosong, ini harus berupa jumlah replika; jika tidak, jumlah ini harus sama dengan jumlah replika di setiap grup.
replica_groups	Vektor ReplicaGroup	Setiap grup berisi daftar ID replika.

Di bawah ini menampilkan contoh 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);

Dalam contoh ini, ada 4 core yang berpartisipasi dalam Alltoall. Pada setiap core, operand dibagi menjadi 4 bagian di sepanjang dimensi 0, sehingga setiap bagian memiliki bentuk f32[4,4]. Keempat bagian tersebut tersebar ke semua inti. Kemudian, setiap core akan menyambungkan bagian yang diterima di sepanjang dimensi 1, dalam urutan core 0-4. Jadi, output di setiap core memiliki bentuk f32[16,4].

BatchNormGrad

Lihat juga XlaBuilder::BatchNormGrad dan makalah normalisasi batch asli untuk mengetahui deskripsi mendetail tentang algoritma.

Menghitung gradien batch norm.

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

Argumen	Jenis	Semantik
operand	XlaOp	Array n dimensi yang akan dinormalisasi (x)
scale	XlaOp	Array 1 dimensi (\(\gamma\))
mean	XlaOp	Array 1 dimensi (\(\mu\))
variance	XlaOp	Array 1 dimensi (\(\sigma^2\))
grad_output	XlaOp	Gradien yang diteruskan ke BatchNormTraining (\(\nabla y\))
epsilon	float	Nilai epsilon (\(\epsilon\))
feature_index	int64	Indeks ke dimensi fitur di operand

Untuk setiap fitur dalam dimensi fitur (feature_index adalah indeks untuk dimensi fitur di operand), operasi menghitung gradien dengan mengacu pada operand, offset, dan scale di semua dimensi lainnya. feature_index harus berupa indeks yang valid untuk dimensi fitur di operand.

Tiga gradien ditentukan oleh formula berikut (dengan asumsi array 4 dimensi sebagai operand dan dengan indeks dimensi fitur l, ukuran tumpukan m, serta ukuran spasial w dan 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} \]

Input mean dan variance mewakili nilai momen di seluruh dimensi batch dan spasial.

Jenis output adalah tuple dari tiga nama sebutan channel:

Output	Jenis	Semantik
grad_operand	XlaOp	gradien terhadap input operand ($\nabla x$)
grad_scale	XlaOp	gradien yang terkait dengan scale input ($\nabla \gamma$)
grad_offset	XlaOp	gradien sehubungan dengan input offset($\nabla \beta$)

BatchNormInference

Lihat juga XlaBuilder::BatchNormInference dan makalah normalisasi batch asli untuk deskripsi mendetail tentang algoritma.

Mennormalisasi array di seluruh dimensi batch dan spasial.

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

Argumen	Jenis	Semantik
operand	XlaOp	array n dimensi yang akan dinormalisasi
scale	XlaOp	Array 1 dimensi
offset	XlaOp	Array 1 dimensi
mean	XlaOp	Array 1 dimensi
variance	XlaOp	Array 1 dimensi
epsilon	float	Nilai Epsilon
feature_index	int64	Indeks ke dimensi fitur di operand

Untuk setiap fitur dalam dimensi fitur (feature_index adalah indeks untuk dimensi fitur di operand), operasi tersebut menghitung rata-rata dan varians di seluruh dimensi lainnya dan menggunakan rata-rata dan varians untuk menormalkan setiap elemen di operand. feature_index harus berupa indeks yang valid untuk dimensi fitur di operand.

BatchNormInference sama dengan memanggil BatchNormTraining tanpa menghitung mean dan variance untuk setiap batch. Sebagai gantinya, mean dan variance input digunakan sebagai nilai estimasi. Tujuan operasi ini adalah untuk mengurangi latensi dalam inferensi, sehingga namanya BatchNormInference.

Outputnya adalah array normalisasi n-dimensi dengan bentuk yang sama seperti input operand.

BatchNormTraining

Lihat juga XlaBuilder::BatchNormTraining dan the original batch normalization paper untuk deskripsi mendetail tentang algoritma.

Menormalkan array di seluruh dimensi batch dan spasial.

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

Argumen	Jenis	Semantik
operand	XlaOp	n array dimensi yang akan dinormalisasi (x)
scale	XlaOp	Array 1 dimensi (\(\gamma\))
offset	XlaOp	Array 1 dimensi (\(\beta\))
epsilon	float	Nilai Epsilon (\(\epsilon\))
feature_index	int64	Indeks ke dimensi fitur di operand

Untuk setiap fitur dalam dimensi fitur (feature_index adalah indeks untuk dimensi fitur di operand), operasi menghitung rata-rata dan varians di semua dimensi lainnya dan menggunakan rata-rata dan varians untuk menormalisasi setiap elemen di operand. feature_index harus berupa indeks yang valid untuk dimensi fitur di operand.

Algoritme berjalan sebagai berikut untuk setiap batch di operand \(x\) yang berisi elemen m dengan w dan h sebagai ukuran dimensi spasial (dengan asumsi operand adalah array 4 dimensi):

• Menghitung rata-rata batch \(\mu_l\) untuk setiap fitur l dalam dimensi fitur: \(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\)

• Menghitung varian batch \(\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$

• Menormalisasi, menskalakan, dan menggeser: \(y_{ijkl}=\frac{\gamma_l(x_{ijkl}-\mu_l)}{\sqrt[2]{\sigma^2_l+\epsilon} }+\beta_l\)

Nilai epsilon, biasanya angka kecil, ditambahkan untuk menghindari error pembagian dengan nol.

Jenis output adalah tuple dari tiga XlaOp:

Output	Jenis	Semantik
output	XlaOp	Array dimensi n dengan bentuk yang sama seperti input operand (y)
batch_mean	XlaOp	Array 1 dimensi (\(\mu\))
batch_var	XlaOp	Array 1 dimensi (\(\sigma^2\))

batch_mean dan batch_var adalah momen yang dihitung di seluruh dimensi batch dan spasial menggunakan formula di atas.

BitcastConvertType

Lihat juga XlaBuilder::BitcastConvertType.

Serupa dengan tf.bitcast di TensorFlow, melakukan operasi bitcast elemen per elemen dari bentuk data ke bentuk target. Ukuran input dan output harus cocok: misalnya, elemen s32 menjadi elemen f32 melalui rutinitas bitcast, dan satu elemen s32 akan menjadi empat elemen s8. Bitcast diimplementasikan sebagai cast level rendah sehingga mesin dengan representasi floating point yang berbeda akan memberikan hasil yang berbeda.

BitcastConvertType(operand, new_element_type)

Argumen	Jenis	Semantik
operand	XlaOp	array jenis T dengan dimensi D
new_element_type	PrimitiveType	jenis U

Dimensi operand dan bentuk target harus cocok, terlepas dari dimensi terakhir yang akan berubah berdasarkan rasio ukuran primitif sebelum dan sesudah konversi.

Jenis elemen sumber dan tujuan tidak boleh berupa tuple.

Konversi bitcast ke jenis primitif dengan lebar yang berbeda

Instruksi HLO BitcastConvert mendukung kasus saat ukuran jenis elemen output T' tidak sama dengan ukuran elemen input T. Karena seluruh operasi secara konseptual merupakan bitcast dan tidak mengubah byte yang mendasarinya, bentuk elemen output harus berubah. Untuk B = sizeof(T), B' = sizeof(T'), ada dua kemungkinan kasus.

Pertama, saat B > B', bentuk output mendapatkan dimensi minor baru dengan ukuran B/B'. Contoh:

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

Aturannya tetap sama untuk skalar efektif:

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

Atau, untuk B' > B, petunjuk ini mewajibkan dimensi logis terakhir dari bentuk input sama dengan B'/B, dan dimensi ini dihapus selama konversi:

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

Perhatikan bahwa konversi antara bitwidth yang berbeda tidak bergantung pada elemen.

Siaran

Lihat juga XlaBuilder::Broadcast.

Menambahkan dimensi ke array dengan menduplikasi data dalam array.

Broadcast(operand, broadcast_sizes)

Argumen	Jenis	Semantik
operand	XlaOp	Array yang akan diduplikasi
broadcast_sizes	ArraySlice<int64>	Ukuran dimensi baru

Dimensi baru disisipkan di sebelah kiri, yaitu jika broadcast_sizes memiliki nilai {a0, ..., aN} dan bentuk operand memiliki dimensi {b0, ..., bM}, maka bentuk output memiliki dimensi {a0, ..., aN, b0, ..., bM}.

Indeks dimensi baru ke dalam salinan operand, yaitu

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

Misalnya, jika operand adalah f32 skalar dengan nilai 2.0f, dan broadcast_sizes adalah {2, 3}, hasilnya akan berupa array dengan bentuk f32[2, 3] dan semua nilai dalam hasilnya akan menjadi 2.0f.

BroadcastInDim

Lihat juga XlaBuilder::BroadcastInDim.

Memperluas ukuran dan peringkat array dengan menduplikasi data dalam array.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

Argumen	Jenis	Semantik
operand	XlaOp	Array yang akan diduplikasi
out_dim_size	ArraySlice<int64>	Ukuran dimensi bentuk target
broadcast_dimensions	ArraySlice<int64>	Dimensi dalam bentuk target yang sesuai dengan setiap dimensi bentuk operand

Mirip dengan Broadcast, tetapi memungkinkan penambahan dimensi di mana saja dan memperluas dimensi yang ada dengan ukuran 1.

operand disiarkan ke bentuk yang dijelaskan oleh out_dim_size. broadcast_dimensions memetakan dimensi operand ke dimensi bentuk target, yaitu dimensi ke-i dari operand dipetakan ke dimensi ke-broadcast_dimension[i] dari bentuk output. Dimensi operand harus memiliki ukuran 1 atau memiliki ukuran yang sama dengan dimensi dalam bentuk output yang dipetakan. Dimensi yang tersisa diisi dengan dimensi ukuran 1. Siaran dimensi degenere kemudian disiarkan di sepanjang dimensi degenere ini untuk mencapai bentuk output. Semantik dijelaskan secara mendetail di halaman siaran.

Telepon

Lihat juga XlaBuilder::Call.

Memanggil komputasi dengan argumen yang diberikan.

Call(computation, args...)

Argumen	Jenis	Semantik
computation	XlaComputation	komputasi jenis T_0, T_1, ..., T_{N-1} -> S dengan parameter N dari jenis arbitrer
args	urutan N XlaOp dtk	N argumen dari jenis arbitrer

Aritmetika dan jenis args harus cocok dengan parameter computation. Anda dapat tidak memiliki args.

Cholesky

Lihat juga XlaBuilder::Cholesky.

Menghitung dekomposisi Cholesky dari batch matriks definit positif simetris (Hermitian).

Cholesky(a, lower)

Argumen	Jenis	Semantik
a	XlaOp	array dengan peringkat > 2 dari jenis kompleks atau floating point.
lower	bool	apakah akan menggunakan segitiga atas atau bawah a.

Jika lower adalah true, komputasi matriks segitiga bawah l sehingga $a = l . l^T$. Jika lower adalah false, komputasi matriks segitiga atas u sehingga \(a = u^T . u\).

Data input hanya dibaca dari segitiga bawah/atas a, bergantung pada nilai lower. Nilai dari segitiga lain akan diabaikan. Data output ditampilkan dalam segitiga yang sama; nilai dalam segitiga lainnya ditentukan oleh implementasi dan dapat berupa apa saja.

Jika peringkat a lebih besar dari 2, a diperlakukan sebagai batch matriks, dengan semua dimensi kecuali 2 minor merupakan dimensi batch.

Jika a tidak simetris (Hermitian) positif pasti, hasilnya ditentukan oleh implementasi.

Penjepit

Lihat juga XlaBuilder::Clamp.

Menjepit operand ke dalam rentang antara nilai minimum dan maksimum.

Clamp(min, operand, max)

Argumen	Jenis	Semantik
min	XlaOp	array tipe T
operand	XlaOp	array jenis T
max	XlaOp	array tipe T

Dengan mempertimbangkan nilai operand serta nilai minimum dan maksimum, menampilkan operand jika berada dalam rentang antara minimum dan maksimum, jika tidak, menampilkan nilai minimum jika operand berada di bawah rentang ini atau nilai maksimum jika operand berada di atas rentang ini. Artinya, clamp(a, x, b) = min(max(a, x), b).

Ketiga array harus memiliki bentuk yang sama. Atau, sebagai bentuk siaran yang dibatasi, min dan/atau max dapat berupa skalar dari jenis T.

Contoh dengan skalar min dan 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};

Ciutkan

Lihat juga XlaBuilder::Collapse dan operasi tf.reshape.

Menciutkan dimensi array menjadi satu dimensi.

Collapse(operand, dimensions)

Argumen	Jenis	Semantik
operand	XlaOp	array jenis T
dimensions	Vektor int64	subhimpunan dari dimensi T secara berurutan.

Ciutkan akan mengganti subset dimensi operand yang diberikan dengan satu dimensi. Argumen input adalah array arbitrer dari jenis T dan vektor konstanta waktu kompilasi dari indeks dimensi. Indeks dimensi harus berurutan (angka dimensi rendah ke tinggi), subset berturut-turut dari dimensi T. Dengan demikian, {0, 1, 2}, {0, 1}, atau {1, 2} adalah kumpulan dimensi yang valid, tetapi {1, 0} atau {0, 2} tidak valid. Dimensi tersebut diganti oleh satu dimensi baru, pada posisi yang sama dalam urutan dimensi dengan yang diganti, dengan ukuran dimensi baru yang sama dengan hasil kali ukuran dimensi asli. Angka dimensi terendah di dimensions adalah dimensi bervariasi paling lambat (paling besar) di tingkatan loop yang menciutkan dimensi ini, dan jumlah dimensi tertinggi memiliki variasi tercepat (paling kecil). Lihat operator tf.reshape jika diperlukan pengurutan penciutan umum yang lebih umum.

Misalnya, v adalah array 24 elemen:

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

Lihat juga XlaBuilder::CollectivePermute.

CollectivePermute adalah operasi kolektif yang mengirim dan menerima replika silang data.

CollectivePermute(operand, source_target_pairs)

Argumen	Jenis	Semantik
operand	XlaOp	array input dimensi n
source_target_pairs	Vektor <int64, int64>	Daftar pasangan (source_replica_id, target_replica_id). Untuk setiap pasangan, operand dikirim dari replika sumber ke replika target.

Perhatikan bahwa ada batasan berikut pada source_target_pair:

• Setiap dua pasangan tidak boleh memiliki ID replika target yang sama, dan tidak boleh memiliki ID replika sumber yang sama.
• Jika ID replika bukan target dalam pasangan apa pun, output pada replika tersebut adalah tensor yang terdiri dari 0 dengan bentuk yang sama dengan input.

Gabungkan

Lihat juga XlaBuilder::ConcatInDim.

Concatenate menyusun array dari beberapa operand array. Array memiliki tingkat yang sama dengan setiap operand array input (yang harus memiliki tingkat yang sama dengan satu sama lain) dan berisi argumen dalam urutan yang ditentukan.

Concatenate(operands..., dimension)

Argumen	Jenis	Semantik
operands	urutan N XlaOp	Array N dari jenis T dengan dimensi [L0, L1, ...]. Memerlukan N >= 1.
dimension	int64	Nilai dalam interval [0, N) yang memberi nama dimensi yang akan disambungkan di antara operands.

Dengan pengecualian dimension, semua dimensi harus sama. Hal ini karena XLA tidak mendukung array "ragged". Perhatikan juga bahwa nilai peringkat-0 tidak dapat digabungkan (karena tidak mungkin untuk memberi nama dimensi tempat penggabungan terjadi).

Contoh 1 dimensi:

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

Contoh 2 dimensi:

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

Diagram:

Kondisional

Lihat juga XlaBuilder::Conditional.

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

Argumen	Jenis	Semantik
pred	XlaOp	Skalar jenis PRED
true_operand	XlaOp	Argumen jenis \(T_0\)
true_computation	XlaComputation	XlaComputation jenis \(T_0 \to S\)
false_operand	XlaOp	Argumen jenis \(T_1\)
false_computation	XlaComputation	XlaComputation dari jenis \(T_1 \to S\)

Mengeksekusi true_computation jika pred adalah true, false_computation jika pred adalah false, dan menampilkan hasilnya.

true_computation harus menerima satu argumen jenis \(T_0\) dan akan dipanggil dengan true_operand yang harus berjenis sama. false_computation harus mengambil satu argumen jenis \(T_1\) dan akan dipanggil dengan false_operand yang harus memiliki jenis yang sama. Jenis nilai true_computation dan false_computation yang ditampilkan harus sama.

Perhatikan bahwa hanya satu dari true_computation dan false_computation yang akan dijalankan, bergantung pada nilai pred.

Conditional(branch_index, branch_computations, branch_operands)

Argumen	Jenis	Semantik
branch_index	XlaOp	Skalar dari jenis S32
branch_computations	urutan N XlaComputation	XlaComputation jenis \(T_0 \to S , T_1 \to S , ..., T_{N-1} \to S\)
branch_operands	urutan N XlaOp	Argumen jenis \(T_0 , T_1 , ..., T_{N-1}\)

Mengeksekusi branch_computations[branch_index], dan menampilkan hasilnya. Jika branch_index adalah S32 yang < 0 atau >= N, branch_computations[N-1] akan dijalankan sebagai cabang default.

Setiap branch_computations[b] harus menerima satu argumen jenis \(T_b\) dan akan dipanggil dengan branch_operands[b] yang harus berjenis sama. Jenis nilai yang ditampilkan dari setiap branch_computations[b] harus sama.

Perhatikan bahwa hanya salah satu branch_computations yang akan dieksekusi bergantung pada nilai branch_index.

Conv (konvolusi)

Lihat juga XlaBuilder::Conv.

Seperti ConvWithGeneralPadding, tetapi padding ditentukan dengan cara singkat sebagai SAME atau VALID. Padding SAME mengisi input (lhs) dengan nol sehingga output memiliki bentuk yang sama dengan input saat tidak memperhitungkan langkah. Padding VALID berarti tidak ada padding.

ConvWithGeneralPadding (konvolusi)

Lihat juga XlaBuilder::ConvWithGeneralPadding.

Menghitung konvolusi jenis yang digunakan dalam jaringan saraf. Di sini, konvolusi dapat dianggap sebagai jendela n-dimensi yang bergerak melintasi area dasar n-dimensi dan komputasi dilakukan untuk setiap kemungkinan posisi jendela.

Argumen	Jenis	Semantik
lhs	XlaOp	array input peringkat n+2
rhs	XlaOp	peringkat n+2 array bobot kernel
window_strides	ArraySlice<int64>	Array langkah n-d kernel
padding	ArraySlice< pair<int64,int64>>	Array n-d dari padding (rendah, tinggi)
lhs_dilation	ArraySlice<int64>	array faktor dilatasi lhs n-d
rhs_dilation	ArraySlice<int64>	array faktor dilatasi rhs n-d
feature_group_count	int64	jumlah grup fitur
batch_group_count	int64	jumlah batch group

Misalkan n adalah jumlah dimensi spasial. Argumen lhs adalah array peringkat n+2 yang menjelaskan area dasar. Ini disebut input, meskipun tentu saja rhs juga merupakan input. Dalam jaringan saraf, ini adalah aktivasi input. Dimensi n+2 adalah, dalam urutan ini:

• batch: Setiap koordinat dalam dimensi ini mewakili input independen yang melakukan konvolusi.
• z/depth/features: Setiap posisi (y,x) di area dasar memiliki vektor yang terkait dengannya, yang masuk ke dimensi ini.
• spatial_dims: Menjelaskan dimensi spasial n yang menentukan area dasar yang dilalui jendela.

Argumen rhs adalah array peringkat n+2 yang menjelaskan filter konvolusional/kernel/window. Dimensinya adalah, dalam urutan ini:

• output-z: Dimensi z dari output.
• input-z: Ukuran dimensi ini dikalikan feature_group_count harus sama dengan ukuran dimensi z di lhs.
• spatial_dims: Menjelaskan dimensi spasial n yang menentukan jendela n-d yang bergerak di seluruh area dasar.

Argumen window_strides menentukan langkahnya langkah jendela konvolusional dalam dimensi spasial. Misalnya, jika langkah dalam dimensi spasial pertama adalah 3, jendela hanya dapat ditempatkan pada koordinat yang indeks spasial pertama dibagi 3.

Argumen padding menentukan jumlah padding nol yang akan diterapkan ke area dasar. Jumlah padding dapat negatif -- nilai absolut padding negatif menunjukkan jumlah elemen yang akan dihapus dari dimensi yang ditentukan sebelum melakukan konvolusi. padding[0] menentukan padding untuk dimensi y dan padding[1] menentukan padding untuk dimensi x. Setiap pasangan memiliki padding rendah sebagai elemen pertama dan padding tinggi sebagai elemen kedua. Padding rendah diterapkan ke arah indeks yang lebih rendah, sedangkan padding tinggi diterapkan ke arah indeks yang lebih tinggi. Misalnya, jika padding[1] adalah (2,3), maka akan ada padding dengan 2 angka nol di sebelah kiri dan dengan 3 angka nol di sebelah kanan dalam dimensi spasial kedua. Menggunakan padding setara dengan menyisipkan nilai nol yang sama ke dalam input (lhs) sebelum melakukan konvolusi.

Argumen lhs_dilation dan rhs_dilation menentukan faktor dilatasi yang akan diterapkan ke lhs dan rhs, masing-masing, di setiap dimensi spasial. Jika faktor dilatasi dalam dimensi spasial adalah d, lubang d-1 secara implisit akan ditempatkan di antara setiap entri dalam dimensi tersebut, yang akan meningkatkan ukuran array. Lubang diisi dengan nilai no-op, yang untuk konvolusi berarti nol.

Dilatasi rhs juga disebut konvolusi atrous. Untuk detail selengkapnya, lihat tf.nn.atrous_conv2d. Dilatasi lhs juga disebut konvolusi yang ditransposisikan. Untuk detail selengkapnya, lihat tf.nn.conv2d_transpose.

Argumen feature_group_count (nilai default 1) dapat digunakan untuk konvolusi yang dikelompokkan. feature_group_count harus menjadi pembagi dimensi fitur input dan output. Jika feature_group_count lebih besar dari 1, artinya secara konseptual dimensi fitur input dan output serta dimensi fitur output rhs dibagi secara merata menjadi banyak grup feature_group_count, dengan setiap grup terdiri dari suburutan fitur yang berurutan. Dimensi fitur input rhs harus sama dengan dimensi fitur input lhs dibagi dengan feature_group_count (sehingga sudah memiliki ukuran grup fitur input). Grup ke-i digunakan bersama untuk menghitung feature_group_count untuk banyak konvolusi terpisah. Hasil dari konvolusi ini digabungkan dalam dimensi fitur output.

Untuk konvolusi kedalaman, argumen feature_group_count akan ditetapkan ke dimensi fitur input, dan filter akan dibentuk ulang dari [filter_height, filter_width, in_channels, channel_multiplier] menjadi [filter_height, filter_width, 1, in_channels * channel_multiplier]. Untuk mengetahui detail selengkapnya, lihat tf.nn.depthwise_conv2d.

Argumen batch_group_count (nilai default 1) dapat digunakan untuk filter yang dikelompokkan selama propagasi mundur. batch_group_count harus merupakan pembagi dari ukuran dimensi batch lhs (input). Jika batch_group_count lebih besar dari 1, berarti dimensi batch output harus berukuran input batch / batch_group_count. batch_group_count harus merupakan pembagi dari ukuran fitur output.

Bentuk output memiliki dimensi berikut, dalam urutan ini:

• batch: Ukuran dimensi ini dikali batch_group_count harus sama dengan ukuran dimensi batch dalam lb.
• z: Ukurannya sama dengan output-z pada kernel (rhs).
• spatial_dims: Satu nilai untuk setiap penempatan jendela convolutional yang valid.

Gambar di atas menunjukkan cara kerja kolom batch_group_count. Secara efektif, kita membagi setiap batch lhs menjadi grup batch_group_count, dan melakukan hal yang sama untuk fitur output. Kemudian, untuk setiap grup ini, kita melakukan konvolusi berpasangan dan menggabungkan output di sepanjang dimensi fitur output. Semantik operasional dari semua dimensi lainnya (fitur dan spasial) tetap sama.

Penempatan jendela convolutional yang valid ditentukan oleh langkah dan ukuran area dasar setelah padding.

Untuk menjelaskan fungsi konvolusi, pertimbangkan konvolusi 2d, dan pilih beberapa koordinat batch, z, y, x tetap dalam output. Kemudian, (y,x) adalah posisi sudut jendela dalam area dasar (misalnya, sudut kiri atas, bergantung pada cara Anda menafsirkan dimensi spasial). Sekarang kita memiliki jendela 2d, yang diambil dari area dasar, dengan setiap titik 2d terkait dengan vektor 1d, sehingga kita mendapatkan kotak 3d. Dari kernel konvolusional, karena kita telah memperbaiki koordinat output z, kita juga memiliki kotak 3d. Kedua kotak memiliki dimensi yang sama, sehingga kita dapat mengambil jumlah produk per elemen antara kedua kotak (mirip dengan produk titik). Itu adalah nilai output.

Perhatikan bahwa jika output-z adalah, misalnya, 5, maka setiap posisi jendela menghasilkan 5 nilai dalam output ke dimensi z output. Nilai ini berbeda di bagian kernel convolutional yang digunakan - ada kotak nilai 3D terpisah yang digunakan untuk setiap koordinat output-z. Jadi, Anda bisa menganggapnya sebagai 5 konvolusi terpisah dengan filter yang berbeda untuk masing-masing.

Berikut adalah kode semu untuk konvolusi 2d dengan padding dan striding:

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

ConvertElementType

Lihat juga XlaBuilder::ConvertElementType.

Serupa dengan static_cast berbasis elemen di C++, melakukan operasi konversi berdasarkan elemen dari bentuk data ke bentuk target. Dimensi harus cocok, dan konversi adalah konversi per elemen; misalnya, elemen s32 menjadi elemen f32 melalui rutinitas konversi s32-ke-f32.

ConvertElementType(operand, new_element_type)

Argumen	Jenis	Semantik
operand	XlaOp	array jenis T dengan dimensi D
new_element_type	PrimitiveType	ketik U

Dimensi operand dan bentuk target harus cocok. Jenis elemen sumber dan tujuan tidak boleh berupa tuple.

Konversi seperti T=s32 ke U=f32 akan melakukan rutinitas konversi int-to-float yang dinormalisasi seperti round-to-nearest-even.

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

Melakukan AllReduce dengan komputasi penjumlahan.

CustomCall

Lihat juga XlaBuilder::CustomCall.

Memanggil fungsi yang disediakan pengguna dalam komputasi.

CustomCall(target_name, args..., shape)

Argumen	Jenis	Semantik
target_name	string	Nama fungsi. Petunjuk panggilan akan dikeluarkan yang menargetkan nama simbol ini.
args	urutan N XlaOp	N argumen dari jenis arbitrer, yang akan diteruskan ke fungsi.
shape	Shape	Bentuk output fungsi

Tanda tangan fungsi sama, terlepas dari arity atau jenis argumen:

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

Misalnya, jika CustomCall digunakan sebagai berikut:

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

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

Berikut adalah contoh implementasi 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];
  // ...
}

Fungsi yang disediakan pengguna tidak boleh memiliki efek samping dan eksekusinya harus idempotent.

Titik

Lihat juga XlaBuilder::Dot.

Dot(lhs, rhs)

Argumen	Jenis	Semantik
lhs	XlaOp	array tipe T
rhs	XlaOp	array tipe T

Semantik persis dari operasi ini bergantung pada peringkat operand:

Input	Output	Semantik
vektor [n] dot vektor [n]	skalar	produk vektor titik
matriks [m x k] vektor dot [k]	vektor [m]	perkalian matriks-vektor
matriks [m x k] dot matriks [k x n]	matriks [m x n]	perkalian matriks-matriks

Operasi ini melakukan jumlah produk pada dimensi kedua lhs (atau dimensi pertama jika memiliki peringkat 1) dan dimensi pertama rhs. Ini adalah dimensi "diperkecil". Dimensi yang dikontrak dari lhs dan rhs harus berukuran sama. Dalam praktiknya, operator ini dapat digunakan untuk melakukan perkalian titik antara vektor, perkalian vektor/matriks, atau perkalian matriks/matriks.

DotGeneral

Lihat juga XlaBuilder::DotGeneral.

DotGeneral(lhs, rhs, dimension_numbers)

Argumen	Jenis	Semantik
lhs	XlaOp	array tipe T
rhs	XlaOp	array tipe T
dimension_numbers	DotDimensionNumbers	nomor dimensi kontrak dan batch

Mirip dengan Titik, tetapi memungkinkan nomor dimensi kontrak dan batch ditentukan untuk lhs dan rhs.

Kolom DotDimensionNumbers	Jenis	Semantik
lhs_contracting_dimensions	int64 berulang	lhs nomor dimensi kontrak
rhs_contracting_dimensions	int64 berulang	rhs nomor dimensi kontrak
lhs_batch_dimensions	int64 berulang	lhs nomor dimensi batch
rhs_batch_dimensions	int64 berulang	Nomor dimensi batch rhs

DotGeneral melakukan jumlah produk berdasarkan dimensi kontrak yang ditentukan dalam dimension_numbers.

Nomor dimensi kontrak terkait dari lhs dan rhs tidak harus sama, tetapi harus memiliki ukuran dimensi yang sama.

Contoh dengan nomor dimensi kontrak:

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

Nomor dimensi batch terkait dari lhs dan rhs harus memiliki ukuran dimensi yang sama.

Contoh dengan nomor dimensi batch (matriks ukuran batch 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} } }

Input	Output	Semantik
[b0, m, k] dot [b0, k, n]	[b0, m, n]	matmul batch
[b0, b1, m, k] dot [b0, b1, k, n]	[b0, b1, m, n]	matmul batch

Oleh karena itu, angka dimensi yang dihasilkan dimulai dengan dimensi batch, lalu dimensi non-kontrak/non-batch lhs, dan terakhir dimensi non-kontrak/non-batch rhs.

DynamicSlice

Lihat juga XlaBuilder::DynamicSlice.

DynamicSlice mengekstrak sub-array dari array input pada start_indices dinamis. Ukuran irisan di setiap dimensi diteruskan dalam size_indices, yang menentukan titik akhir interval irisan eksklusif di setiap dimensi: [awal, awal + ukuran). Bentuk start_indices harus memiliki peringkat == 1, dengan ukuran dimensi sama dengan peringkat operand.

DynamicSlice(operand, start_indices, size_indices)

Argumen	Jenis	Semantik
operand	XlaOp	Array dimensi N tipe T
start_indices	urutan N XlaOp	Daftar bilangan bulat skalar N yang berisi indeks awal irisan untuk setiap dimensi. Nilai harus lebih besar dari atau sama dengan nol.
size_indices	ArraySlice<int64>	Daftar bilangan bulat N yang berisi ukuran slice untuk setiap dimensi. Setiap nilai harus lebih besar dari nol, dan start + size harus kurang dari atau sama dengan ukuran dimensi untuk menghindari penggabungan ukuran dimensi modulo.

Indeks slice yang efektif dihitung dengan menerapkan transformasi berikut untuk setiap indeks i dalam [1, N) sebelum menjalankan slice:

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

Hal ini memastikan bahwa slice yang diekstrak selalu berada dalam batas sehubungan dengan array operand. Jika slice berada dalam batas sebelum transformasi diterapkan, transformasi tidak akan berpengaruh.

Contoh 1 dimensi:

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

DynamicSlice(a, s, {2}) produces:
{2.0, 3.0}

Contoh 2 dimensi:

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

Lihat juga XlaBuilder::DynamicUpdateSlice.

DynamicUpdateSlice menghasilkan hasil yang merupakan nilai array input operand, dengan slice update yang ditimpa di start_indices. Bentuk update menentukan bentuk sub-array hasil yang diperbarui. Bentuk start_indices harus memiliki peringkat == 1, dengan ukuran dimensi sama dengan peringkat operand.

DynamicUpdateSlice(operand, update, start_indices)

Argumen	Jenis	Semantik
operand	XlaOp	Array dimensi N dari jenis T
update	XlaOp	Array dimensi N dari jenis T yang berisi pembaruan slice. Setiap dimensi bentuk pembaruan harus lebih besar dari nol, dan start + update harus kurang dari atau sama dengan ukuran operand untuk setiap dimensi agar tidak menghasilkan indeks pembaruan di luar batas.
start_indices	urutan N XlaOp	Daftar bilangan bulat skalar N yang berisi indeks awal slice untuk setiap dimensi. Nilai harus lebih besar dari atau sama dengan nol.

Indeks slice yang efektif dihitung dengan menerapkan transformasi berikut untuk setiap indeks i dalam [1, N) sebelum menjalankan slice:

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

Hal ini memastikan bahwa slice yang diperbarui selalu berada dalam batas sehubungan dengan array operand. Jika slice berada dalam batas sebelum transformasi diterapkan, transformasi tidak akan berpengaruh.

Contoh 1 dimensi:

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}

Contoh 2 dimensi:

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

Operasi aritmetika biner element-wise

Lihat juga XlaBuilder::Add.

Serangkaian operasi aritmetika biner element-wise didukung.

Op(lhs, rhs)

Dengan Op adalah salah satu dari Add (penambahan), Sub(pengurangan), Mul (perkalian), Div (pembagian), Pow (daya), Rem (sisa), Max (maksimum), Min (minimum), And (logika AND), Or (logika OR), Xor (logika XOR), ShiftLeft (Pergeseran Kiri), ShiftRightArithmetic (aritmatika/Pergeseran Kanan} (pergeseran Kanan) {14/logika)ShiftRightLogicalAtan2Complex

Argumen	Jenis	Semantik
lhs	XlaOp	operand sisi kiri: array dari jenis T
rhs	XlaOp	operand sisi kanan: array dari jenis T

Bentuk argumen harus serupa atau kompatibel. Lihat dokumentasi siaran tentang arti kompatibilitas bentuk. Hasil operasi memiliki bentuk yang merupakan hasil dari menyebarkan dua array input. Dalam varian ini, operasi antara array dengan pangkat yang berbeda tidak didukung, kecuali jika salah satu operand adalah skalar.

Jika Op adalah Rem, tanda hasilnya diambil dari dividen, dan nilai absolut hasilnya selalu kurang dari nilai absolut pembagi.

Overflow pembagian bilangan bulat (pembagian/sisa bertanda/tanpa tanda dengan nol atau pembagian/sisa bertanda INT_SMIN dengan -1) menghasilkan nilai yang ditentukan implementasi.

Terdapat varian alternatif dengan dukungan penyiaran dengan peringkat berbeda untuk operasi berikut:

Op(lhs, rhs, broadcast_dimensions)

Dengan Op sama dengan yang di atas. Varian operasi ini harus digunakan untuk operasi aritmatika antara array dengan peringkat yang berbeda (seperti menambahkan matriks ke vektor).

Operand broadcast_dimensions tambahan adalah potongan bilangan bulat yang digunakan untuk memperluas peringkat operand berperingkat lebih rendah hingga ke urutan operand yang berperingkat lebih tinggi. broadcast_dimensions memetakan dimensi bentuk berperingkat lebih rendah ke dimensi bentuk berperingkat lebih tinggi. Dimensi yang belum dipetakan dari bentuk yang diperluas diisi dengan dimensi ukuran satu. Ubah siaran dimensi, lalu siarkan bentuk di sepanjang dimensi yang mengalami degenerasi ini untuk menyamakan bentuk kedua operand. Semantik dijelaskan secara mendetail di halaman siaran.

Operasi perbandingan berdasarkan elemen

Lihat juga XlaBuilder::Eq.

Serangkaian operasi perbandingan biner elemen standar didukung. Perhatikan bahwa semantik perbandingan floating point IEEE 754 standar berlaku saat membandingkan jenis floating point.

Op(lhs, rhs)

Dengan Op adalah salah satu dari Eq (sama dengan), Ne (tidak sama dengan), Ge (lebih besar atau sama dengan), Gt (lebih besar dari), Le (lebih kecil atau sama dengan), Lt (lebih kecil dari). Kumpulan operator lain, EqTotalOrder, NeTotalOrder, GeTotalOrder, GtTotalOrder, LeTotalOrder, dan LtTotalOrder, menyediakan fungsi yang sama, kecuali bahwa operator tersebut juga mendukung total order pada bilangan floating point, dengan menerapkan -NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.

Argumen	Jenis	Semantik
lhs	XlaOp	operand sisi kiri: array dari jenis T
rhs	XlaOp	operand sisi kanan: array dari jenis T

Bentuk argumen harus serupa atau kompatibel. Lihat dokumentasi siaran tentang arti kompatibilitas bentuk. Hasil operasi memiliki bentuk yang merupakan hasil dari penyiaran dua array input dengan jenis elemen PRED. Dalam varian ini, operasi antara array dengan pangkat yang berbeda tidak didukung, kecuali jika salah satu operand adalah skalar.

Terdapat varian alternatif dengan dukungan penyiaran dengan peringkat berbeda untuk operasi berikut:

Op(lhs, rhs, broadcast_dimensions)

Dengan Op sama seperti di atas. Varian operasi ini harus digunakan untuk operasi perbandingan antara array dengan pangkat yang berbeda (seperti menambahkan matriks ke vektor).

Operand broadcast_dimensions tambahan adalah bagian dari bilangan bulat yang menentukan dimensi yang akan digunakan untuk menyiarkan operand. Semantik dijelaskan secara mendetail di halaman siaran.

Fungsi unary {i>element<i}-{i>wise<i}

XlaBuilder mendukung fungsi unary berbasis elemen ini:

Abs(operand) Abs per elemen x -> |x|.

Cbrt(operand) Operasi akar kubik element-wise x -> cbrt(x).

Ceil(operand) Ceil berbasis elemen x -> ⌈x⌉.

Clz(operand) Menghitung nol di awal secara element-wise.

Cos(operand) Kosinus per elemen x -> cos(x).

Erf(operand) Fungsi error {i>element<i}-{i>wise<i} x -> erf(x) dengan

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

Exp(operand) Eksponen alami per elemen x -> e^x.

Expm1(operand) Eksponen alami per elemen dikurangi satu x -> e^x - 1.

Floor(operand) Lantai yang menangani elemen x -> ⌊x⌋.

Imag(operand) Bagian imajiner per elemen dari bentuk kompleks (atau riil). x -> imag(x). Jika operand adalah jenis floating point, akan menghasilkan 0.

IsFinite(operand) Menguji apakah setiap elemen operand bersifat terbatas, yaitu, bukan tak terhingga positif atau negatif, dan bukan NaN. Menampilkan array nilai PRED dengan bentuk yang sama seperti input, dengan setiap elemen adalah true jika dan hanya jika elemen input yang sesuai terbatas.

Log(operand) Logaritma natural per elemen x -> ln(x).

Log1p(operand) Logaritma natural yang digeser per elemen x -> ln(1+x).

Logistic(operand) Komputasi fungsi logistik yang menangani setiap elemen x -> logistic(x).

Neg(operand) Negasi setiap elemen x -> -x.

Not(operand) Logika per elemen bukan x -> !(x).

PopulationCount(operand) Menghitung jumlah bit yang ditetapkan di setiap elemen operand.

Real(operand) Bagian riil per elemen dari bentuk kompleks (atau riil). x -> real(x). Jika operand adalah jenis floating point, akan menampilkan nilai yang sama.

Round(operand) Pembulatan berbasis elemen, mengikat dari nol.

RoundNearestEven(operand) Pembulatan per elemen, terikat dengan bilangan genap terdekat.

Rsqrt(operand) Invers element-wise dari operasi akar kuadrat x -> 1.0 / sqrt(x).

Sign(operand) Operasi penandaan {i>element<i}-wise x -> sgn(x) dengan

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

menggunakan operator perbandingan jenis elemen operand.

Sin(operand) Sinus per elemen x -> sin(x).

Sqrt(operand) Operasi akar kuadrat element-wise x -> sqrt(x).

Tan(operand) Garis tangen berbasis elemen x -> tan(x).

Tanh(operand) Tangen hiperbolik berbasis elemen x -> tanh(x).

Argumen	Jenis	Semantik
operand	XlaOp	Operand ke fungsi

Fungsi diterapkan ke setiap elemen dalam array operand, sehingga menghasilkan array dengan bentuk yang sama. operand diizinkan untuk menjadi skalar (tingkat 0).

Fft

Operasi XLA FFT mengimplementasikan Transformasi Fourier maju dan terbalik untuk input/output yang nyata dan kompleks. FFT multidimensi pada maksimal 3 sumbu didukung.

Lihat juga XlaBuilder::Fft.

Argumen	Jenis	Semantik
operand	XlaOp	Array yang sedang kita ubah Fourier.
fft_type	FftType	Lihat tabel di bawah.
fft_length	ArraySlice<int64>	Panjang domain waktu sumbu yang ditransformasi. Hal ini diperlukan terutama untuk IRFFT agar dapat menyesuaikan ukuran sumbu terdalam, karena RFFT(fft_length=[16]) memiliki bentuk output yang sama dengan RFFT(fft_length=[17]).

FftType	Semantik
FFT	Meneruskan FFT kompleks ke kompleks. Bentuk tidak berubah.
IFFT	FFT kompleks-ke-kompleks terbalik. Bentuk tidak berubah.
RFFT	Meneruskan FFT real-to-complex. Bentuk sumbu terdalam dikurangi menjadi fft_length[-1] // 2 + 1 jika fft_length[-1] adalah nilai non-nol, yang menghilangkan bagian konjugat terbalik dari sinyal yang ditransformasikan di luar frekuensi Nyquist.
IRFFT	FFT real-to-kompleks terbalik (yaitu yang kompleks, menghasilkan nilai real). Bentuk sumbu terdalam diperluas ke fft_length[-1] jika fft_length[-1] adalah nilai non-nol, yang menyimpulkan bagian sinyal yang ditransformasi di luar frekuensi Nyquist dari konjugat terbalik entri 1 ke fft_length[-1] // 2 + 1.

FFT Multidimensi

Jika lebih dari 1 fft_length disediakan, hal ini setara dengan menerapkan cascade operasi FFT ke setiap sumbu terdalam. Perhatikan bahwa untuk kasus nyata yang kompleks dan kompleks->real, transformasi sumbu terdalam (secara efektif) dilakukan terlebih dahulu (RFFT; terakhir untuk IRFFT), itulah sebabnya sumbu terdalam adalah sumbu yang mengubah ukuran. Transformasi sumbu lainnya kemudian akan menjadi kompleks->kompleks.

Detail implementasi

FFT CPU didukung oleh TensorFFT Eigen. GPU FFT menggunakan cuFFT.

Mengumpulkan

Operasi pengumpulan XLA menggabungkan beberapa bagian (setiap potongan pada offset runtime yang mungkin berbeda) dari array input.

Semantik Umum

Lihat juga XlaBuilder::Gather. Untuk deskripsi yang lebih intuitif, lihat bagian "Deskripsi Informal" di bawah.

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

Argumen	Jenis	Semantik
operand	XlaOp	Array yang kita kumpulkan.
start_indices	XlaOp	Array yang berisi indeks awal irisan yang kita kumpulkan.
index_vector_dim	int64	Dimensi di start_indices yang "berisi" indeks awal. Lihat di bawah untuk deskripsi mendetail.
offset_dims	ArraySlice<int64>	Kumpulan dimensi dalam bentuk output yang dioffset ke array yang dipotong dari operand.
slice_sizes	ArraySlice<int64>	slice_sizes[i] adalah batas slice di dimensi i.
collapsed_slice_dims	ArraySlice<int64>	Kumpulan dimensi di setiap slice yang diciutkan. Dimensi ini harus berukuran 1.
start_index_map	ArraySlice<int64>	Peta yang menjelaskan cara memetakan indeks di start_indices ke indeks hukum ke dalam operand.
indices_are_sorted	bool	Apakah indeks dijamin akan diurutkan oleh pemanggil.

Untuk memudahkan, kita memberi label dimensi dalam array output, bukan dalam offset_dims, sebagai batch_dims.

Output-nya adalah array peringkat batch_dims.size + offset_dims.size.

operand.rank harus sama dengan jumlah offset_dims.size dan collapsed_slice_dims.size. Selain itu, slice_sizes.size harus sama dengan operand.rank.

Jika index_vector_dim sama dengan start_indices.rank, kita secara implisit menganggap start_indices memiliki dimensi 1 di akhir (yaitu jika start_indices berbentuk [6,7] dan index_vector_dim adalah 2, maka kita secara implisit menganggap bentuk start_indices adalah [6,7,1]).

Batas untuk array output di sepanjang i dimensi dihitung sebagai berikut:

1. Jika i ada di batch_dims (yaitu sama dengan batch_dims[k] untuk beberapa k), kita akan memilih batas dimensi yang sesuai dari start_indices.shape, dengan melewati index_vector_dim (yaitu, pilih start_indices.shape.dims[k] jika k < index_vector_dim dan start_indices.shape.dims[k+1] jika sebaliknya).

2. Jika i ada di offset_dims (yaitu sama dengan offset_dims[k] untuk beberapa k), kita akan memilih batas yang sesuai dari slice_sizes setelah mempertimbangkan collapsed_slice_dims (yaitu kita memilih adjusted_slice_sizes[k] dengan adjusted_slice_sizes adalah slice_sizes dengan batas pada indeks collapsed_slice_dims dihapus).

Secara formal, indeks operand In yang sesuai dengan indeks output tertentu Out dihitung sebagai berikut:

1. Biarkan G = { Out[k] untuk k dalam batch_dims }. Gunakan G untuk membagi vektor S sehingga S[i] = start_indices[Gabungkan(G, i)] dengan Gabungkan(A, b) menyisipkan b pada posisi index_vector_dim ke A. Perhatikan bahwa hal ini ditentukan dengan baik meskipun G kosong: Jika G kosong, maka S = start_indices.

2. Buat indeks awal, Sin, ke dalam operand menggunakan S dengan menceraikan S menggunakan start_index_map. Lebih tepatnya:

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

   2. Sin[_] = 0 jika tidak.

3. Buat indeks Oin ke operand dengan menyebarkan indeks pada dimensi offset di Out sesuai dengan collapsed_slice_dims yang ditetapkan. Lebih tepatnya:

   1. Oin[remapped_offset_dims(k)] = Out[offset_dims[k]] jika k < offset_dims.size (remapped_offset_dims ditentukan di bawah).

   2. Oin[_] = 0 jika tidak.

4. In adalah Oin + Sin dengan + adalah penambahan berdasarkan elemen.

remapped_offset_dims adalah fungsi monoton dengan domain [0, offset_dims.size) dan rentang [0, operand.rank) \ collapsed_slice_dims. Misalnya, jika offset_dims.size adalah 4, operand.rank adalah 6 dan collapsed_slice_dims adalah {0, 2} lalu remapped_offset_dims adalah {0→1, 1→3, 2→4, 3→5}.

Jika indices_are_sorted ditetapkan ke true, XLA dapat mengasumsikan bahwa start_indices diurutkan (dalam urutan menaik, setelah menyebarkan nilainya sesuai dengan start_index_map) oleh pengguna. Jika tidak, maka semantik implementasi akan ditentukan.

Deskripsi dan Contoh Informal

Secara informal, setiap indeks Out dalam array output sesuai dengan elemen E dalam array operand, yang dihitung sebagai berikut:

• Kita menggunakan dimensi batch di Out untuk mencari indeks awal dari start_indices.

• Kami menggunakan start_index_map untuk memetakan indeks awal (yang ukurannya mungkin lebih kecil dari operand.rank) ke indeks awal "full" ke dalam operand.

• Kita akan membagi slice secara dinamis dengan ukuran slice_sizes menggunakan indeks awal penuh.

• Kita membentuk ulang irisan dengan menciutkan dimensi collapsed_slice_dims. Karena semua dimensi irisan yang diciutkan harus memiliki batas 1, bentuk ulang ini selalu sah.

• Kita menggunakan dimensi offset di Out untuk mengindeks ke dalam slice ini guna mendapatkan elemen input, E, yang sesuai dengan indeks output Out.

index_vector_dim disetel ke start_indices.rank - 1 dalam semua contoh berikutnya. Nilai yang lebih menarik untuk index_vector_dim tidak mengubah operasi secara mendasar, tetapi membuat representasi visual menjadi lebih rumit.

Untuk mendapatkan intuisi tentang cara penyatuan semua hal di atas, mari kita lihat contoh yang mengumpulkan 5 slice bentuk [8,6] dari array [16,11]. Posisi irisan ke dalam array [16,11] dapat direpresentasikan sebagai vektor indeks bentuk S64[2], sehingga kumpulan 5 posisi dapat direpresentasikan sebagai array S64[5,2].

Perilaku operasi pengumpulan kemudian dapat digambarkan sebagai transformasi indeks yang menggunakan [G,O0,O1], indeks dalam bentuk output, dan memetakan ke elemen dalam array input dengan cara berikut:

Pertama-tama, kita memilih vektor (X,Y) dari array indeks pengumpulan menggunakan G. Elemen dalam array output pada indeks [G,O0,O1] kemudian adalah elemen dalam array input pada indeks [X+O0,Y+O1].

slice_sizes adalah [8,6], yang menentukan rentang O₀ dan O₁, dan hal ini pada akhirnya menentukan batas slice.

Operasi pengumpulan ini berfungsi sebagai slice dinamis batch dengan G sebagai dimensi batch.

Indeks pengumpulan dapat bersifat multidimensi. Misalnya, versi yang lebih umum dari contoh di atas menggunakan array "gather indices" dengan bentuk [4,5,2] akan menerjemahkan indeks seperti ini:

Sekali lagi, ini berfungsi sebagai slice dinamis batch G0 dan G1 sebagai dimensi batch. Ukuran irisan masih [8,6].

Operasi pengumpulan di XLA memgeneralisasi semantik informal yang diuraikan di atas dengan cara berikut:

1. Kita dapat mengonfigurasi dimensi mana dalam bentuk output yang merupakan dimensi offset (dimensi yang berisi O0, O1 dalam contoh terakhir). Dimensi batch output (dimensi yang berisi G0, G1 pada contoh terakhir) ditentukan sebagai dimensi output yang bukan dimensi offset.

2. Jumlah dimensi offset output yang secara eksplisit ada dalam bentuk output mungkin lebih kecil dari peringkat input. Dimensi "tidak ada" ini, yang tercantum secara eksplisit sebagai collapsed_slice_dims, harus memiliki ukuran slice 1. Karena memiliki ukuran slice 1, satu-satunya indeks yang valid untuknya adalah 0 dan menghapusnya tidak akan menimbulkan ambiguitas.

3. Slice yang diekstrak dari array "Gather Indices" ((X, Y) dalam contoh terakhir) mungkin memiliki lebih sedikit elemen daripada peringkat array input, dan pemetaan eksplisit menentukan cara indeks diperluas agar memiliki peringkat yang sama dengan input.

Sebagai contoh terakhir, kita menggunakan (2) dan (3) untuk menerapkan tf.gather_nd:

G0 dan G1 digunakan untuk memotong indeks awal dari array indeks pengumpulan seperti biasa, kecuali indeks awal hanya memiliki satu elemen, X. Demikian pula, hanya ada satu indeks offset output dengan nilai O0. Namun, sebelum digunakan sebagai indeks ke dalam array input, indeks ini diperluas sesuai dengan "Pemetaan Indeks Pengumpulan" (start_index_map dalam deskripsi formal) dan "Pemetaan Offset" (remapped_offset_dims dalam deskripsi formal) menjadi [X,0] dan [0,O0], yang berjumlah [X,O0]. Dengan kata lain, indeks output [G0,G1,O0] dipetakan ke indeks input [GatherIndices[G0,G1,0],O0] yang memberi kita semantik untuk tf.gather_nd.

slice_sizes untuk kasus ini adalah [1,11]. Secara intuitif, hal ini berarti bahwa setiap indeks X dalam array indeks berkumpul memilih seluruh baris dan hasilnya adalah penggabungan semua baris ini.

GetDimensionSize

Lihat juga XlaBuilder::GetDimensionSize.

Menampilkan ukuran dimensi operand yang diberikan. Operand harus berbentuk array.

GetDimensionSize(operand, dimension)

Argumen	Jenis	Semantik
operand	XlaOp	array input dimensi n
dimension	int64	Nilai dalam interval [0, n) yang menentukan dimensi

SetDimensionSize

Lihat juga XlaBuilder::SetDimensionSize.

Menetapkan ukuran dinamis dimensi tertentu XlaOp. Operand harus berbentuk array.

SetDimensionSize(operand, size, dimension)

Argumen	Jenis	Semantik
operand	XlaOp	Array input n dimensi.
size	XlaOp	int32 yang mewakili ukuran dinamis runtime.
dimension	int64	Nilai dalam interval [0, n) yang menentukan dimensi.

Teruskan operand sebagai hasilnya, dengan dimensi dinamis yang dilacak oleh compiler.

Nilai yang ditambahkan akan diabaikan oleh operasi pengurangan downstream.

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

Lihat juga XlaBuilder::GetTupleElement.

Mengindeks ke tuple dengan nilai konstanta waktu kompilasi.

Nilai harus berupa konstanta waktu kompilasi sehingga inferensi bentuk dapat menentukan jenis nilai yang dihasilkan.

Hal ini analog dengan std::get<int N>(t) di C++. Secara konseptual:

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.

Lihat juga tf.tuple.

Infeed

Lihat juga XlaBuilder::Infeed.

Infeed(shape)

Argumen	Jenis	Semantik
shape	Shape	Bentuk data yang dibaca dari antarmuka Infeed. Kolom tata letak bentuk harus ditetapkan agar cocok dengan tata letak data yang dikirim ke perangkat; jika tidak, perilakunya tidak ditentukan.

Membaca satu item data dari antarmuka streaming Infeed implisit perangkat, menafsirkan data sebagai bentuk yang diberikan dan tata letaknya, dan menampilkan XlaOp data. Beberapa operasi Infeed diizinkan dalam komputasi, tetapi harus ada urutan total di antara operasi Infeed. Misalnya, dua Infeed pada kode di bawah memiliki urutan total karena ada dependensi antara loop sementara.

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

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

Bentuk tuple bertingkat tidak didukung. Untuk bentuk tuple kosong, operasi Infeed secara efektif tidak beroperasi dan berlanjut tanpa membaca data apa pun dari Infeed perangkat.

Iota

Lihat juga XlaBuilder::Iota.

Iota(shape, iota_dimension)

Membuat literal konstan di perangkat, bukan transfer host yang berpotensi besar. Membuat array yang telah menentukan bentuk dan menyimpan nilai yang dimulai dari nol dan bertambah satu di sepanjang dimensi yang ditentukan. Untuk jenis floating point, array yang dihasilkan setara dengan ConvertElementType(Iota(...)) dengan Iota berjenis integral dan konversinya ke jenis floating point.

Argumen	Jenis	Semantik
shape	Shape	Bentuk array yang dibuat oleh Iota()
iota_dimension	int64	Dimensi yang akan ditambah.

Misalnya, Iota(s32[4, 8], 0) menampilkan

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

Pengembalian dengan biaya 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 ]]

Peta

Lihat juga XlaBuilder::Map.

Map(operands..., computation)

Argumen	Jenis	Semantik
operands	urutan N XlaOp	Array N dari jenis T0..T{N-1}
computation	XlaComputation	komputasi jenis T_0, T_1, .., T_{N + M -1} -> S dengan N parameter jenis T dan M dari jenis arbitrer
dimensions	Array int64	array dimensi peta

Menerapkan fungsi skalar pada array operands yang diberikan, menghasilkan array dengan dimensi yang sama, dengan setiap elemen adalah hasil dari fungsi yang dipetakan yang diterapkan ke elemen yang sesuai dalam array input.

Fungsi yang dipetakan adalah komputasi arbitrer dengan batasan bahwa fungsi tersebut memiliki input N dari T jenis skalar dan satu output dengan jenis S. Output memiliki dimensi yang sama dengan operand, kecuali jenis elemen T diganti dengan S.

Misalnya: Map(op1, op2, op3, computation, par1) memetakan elem_out <- computation(elem1, elem2, elem3, par1) di setiap indeks (multi-dimensi) dalam array input untuk menghasilkan array output.

OptimizationBarrier

Memblokir semua kartu pengoptimalan agar tidak memindahkan komputasi melintasi penghalang.

Memastikan bahwa semua input dievaluasi sebelum operator yang bergantung pada output penghalang.

Bantalan

Lihat juga XlaBuilder::Pad.

Pad(operand, padding_value, padding_config)

Argumen	Jenis	Semantik
operand	XlaOp	array jenis T
padding_value	XlaOp	skalar dari jenis T untuk mengisi padding yang ditambahkan
padding_config	PaddingConfig	jumlah padding di kedua tepi (rendah, tinggi) dan di antara elemen setiap dimensi

Memperluas array operand yang ditentukan dengan padding di sekitar array serta di antara elemen array dengan padding_value yang ditentukan. padding_config menentukan jumlah padding tepi dan padding interior untuk setiap dimensi.

PaddingConfig adalah kolom berulang dari PaddingConfigDimension, yang berisi tiga kolom untuk setiap dimensi: edge_padding_low, edge_padding_high, dan interior_padding.

edge_padding_low dan edge_padding_high menentukan jumlah padding yang ditambahkan di bagian bawah (di samping indeks 0) dan bagian atas (di samping indeks tertinggi) dari setiap dimensi. Jumlah padding tepi dapat berupa negatif -- nilai absolut padding negatif menunjukkan jumlah elemen yang akan dihapus dari dimensi yang ditentukan.

interior_padding menentukan jumlah padding yang ditambahkan di antara dua elemen di setiap dimensi; padding tidak boleh negatif. Padding interior terjadi secara logis sebelum padding tepi, sehingga dalam kasus padding tepi negatif, elemen akan dihapus dari operand yang dipadding interior.

Operasi ini tidak akan dilakukan jika semua pasangan padding tepi adalah (0, 0) dan semua nilai padding interior adalah 0. Gambar di bawah menunjukkan contoh nilai edge_padding dan interior_padding yang berbeda untuk array dua dimensi.

Recv

Lihat juga XlaBuilder::Recv.

Recv(shape, channel_handle)

Argumen	Jenis	Semantik
shape	Shape	bentuk data yang akan diterima
channel_handle	ChannelHandle	ID unik untuk setiap pasangan pengiriman/penerimaan

Menerima data bentuk yang diberikan dari petunjuk Send dalam komputasi lain yang memiliki nama sebutan saluran yang sama. Menampilkan XlaOp untuk data yang diterima.

API klien operasi Recv mewakili komunikasi sinkron. Namun, petunjuk ini secara internal diuraikan menjadi 2 petunjuk HLO (Recv dan RecvDone) untuk mengaktifkan transfer data asinkron. Lihat juga HloInstruction::CreateRecv dan HloInstruction::CreateRecvDone.

Recv(const Shape& shape, int64 channel_id)

Mengalokasikan resource yang diperlukan untuk menerima data dari petunjuk Send dengan channel_id yang sama. Menampilkan konteks untuk resource yang dialokasikan, yang digunakan oleh petunjuk RecvDone berikut untuk menunggu hingga transfer data selesai. Konteks adalah tuple dari {receive buffer (shape), request identifier (U32)} dan hanya dapat digunakan oleh petunjuk RecvDone.

RecvDone(HloInstruction context)

Dengan mempertimbangkan konteks yang dibuat oleh petunjuk Recv, menunggu transfer data selesai dan menampilkan data yang diterima.

Reduce (Mengurangi)

Lihat juga XlaBuilder::Reduce.

Menerapkan fungsi pengurangan ke satu atau beberapa array secara paralel.

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

Argumen	Jenis	Semantik
operands	Urutan N XlaOp	Array N dari jenis T_0, ..., T_{N-1}.
init_values	Urutan N XlaOp	Skalar N dari jenis T_0, ..., T_{N-1}.
computation	XlaComputation	komputasi jenis T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1}).
dimensions	Array int64	array dimensi yang tidak berurutan untuk dikurangi.

Dengan keterangan:

• N harus lebih besar dari atau sama dengan 1.
• Komputasi harus "secara kasar" asosiatif (lihat di bawah).
• Semua array input harus memiliki dimensi yang sama.
• Semua nilai awal harus membentuk identitas di bagian computation.
• Jika N = 1, Collate(T) adalah T.
• Jika N > 1, Collate(T_0, ..., T_{N-1}) adalah tuple dari elemen N dari jenis T.

Operasi ini mengurangi satu atau beberapa dimensi dari setiap array input menjadi skalar. Peringkat setiap array yang ditampilkan adalah rank(operand) - len(dimensions). Output op adalah Collate(Q_0, ..., Q_N) dengan Q_i adalah array jenis T_i, dimensinya dijelaskan di bawah.

Backend yang berbeda diizinkan untuk mengatribusikan ulang komputasi pengurangan. Hal ini dapat menyebabkan perbedaan numerik, karena beberapa fungsi pengurangan seperti penambahan tidak asosiatif untuk float. Namun, jika rentang data terbatas, penambahan floating point cukup dekat dengan asosiatif untuk sebagian besar penggunaan praktis.

Contoh

Saat mengurangi satu dimensi dalam satu array 1D dengan nilai [10, 11, 12, 13], dengan fungsi pengurangan f (ini adalah computation), peristiwa tersebut dapat dihitung sebagai

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

tetapi ada juga banyak kemungkinan lain, misalnya

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

Berikut adalah contoh kasar kode pseudo tentang cara menerapkan pengurangan, menggunakan penjumlahan sebagai komputasi pengurangan dengan nilai awal 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]

Berikut adalah contoh pengurangan array 2D (matriks). Bentuk memiliki peringkat 2, dimensi 0 berukuran 2, dan dimensi 1 berukuran 3:

Hasil pengurangan dimensi 0 atau 1 dengan fungsi "add":

Perhatikan bahwa kedua hasil pengurangan adalah array 1D. Diagram menunjukkan satu kolom sebagai kolom dan lainnya sebagai baris untuk memudahkan visual.

Untuk contoh yang lebih kompleks, berikut adalah array 3D. Rangkapnya adalah 3, dimensi 0 berukuran 4, dimensi 1 berukuran 2, dan dimensi 2 berukuran 3. Untuk mempermudah, nilai 1 sampai 6 direplikasi di dimensi 0.

Serupa dengan contoh 2D, kita dapat mengurangi hanya satu dimensi. Misalnya, jika kita mengurangi dimensi 0, kita akan mendapatkan array peringkat 2 dengan semua nilai di dimensi 0 digabungkan menjadi skalar:

|  4   8  12 |
| 16  20  24 |

Jika dimensi 2 dikurangi, kita juga mendapatkan array peringkat 2 dengan semua nilai di dimensi 2 yang dilipat menjadi skalar:

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

Perhatikan bahwa urutan relatif antara dimensi yang tersisa dalam input dipertahankan dalam output, tetapi beberapa dimensi mungkin diberi nomor baru (karena peringkat berubah).

Kita juga dapat mengurangi beberapa dimensi. Dimensi pengurangan penambahan 0 dan 1 menghasilkan array 1D [20, 28, 36].

Mengurangi array 3D di semua dimensinya akan menghasilkan skalar 84.

Pengurangan Variad

Saat N > 1, penerapan fungsi kurangi akan sedikit lebih kompleks, karena diterapkan secara bersamaan ke semua input. Operand disediakan ke komputasi dalam urutan berikut:

• Menjalankan nilai yang dikurangi untuk operand pertama
• ...
• Menjalankan nilai yang dikurangi untuk operand ke-N
• Nilai input untuk operand pertama
• ...
• Nilai input untuk operand ke-N

Misalnya, pertimbangkan fungsi pengurangan berikut, yang dapat digunakan untuk menghitung max dan argmax array 1-D secara paralel:

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

Untuk array Input 1-D V = Float[N], K = Int[N], dan nilai init I_V = Float, I_K = Int, hasil f_(N-1) dari pengurangan di seluruh dimensi input hanya setara dengan aplikasi rekursif berikut:

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

Menerapkan pengurangan ini ke array nilai, dan array indeks berurutan (yaitu iota), akan melakukan iterasi bersama pada array, dan menampilkan tuple yang berisi nilai maksimum dan indeks yang cocok.

ReducePrecision

Lihat juga XlaBuilder::ReducePrecision.

Membuat model efek konversi nilai floating point ke format presisi lebih rendah (seperti IEEE-FP16) dan kembali ke format aslinya. Jumlah bit eksponen dan mantissa dalam format presisi lebih rendah dapat ditentukan secara acak, meskipun semua ukuran bit mungkin tidak didukung di semua implementasi hardware.

ReducePrecision(operand, mantissa_bits, exponent_bits)

Argumen	Jenis	Semantik
operand	XlaOp	array jenis floating point T.
exponent_bits	int32	jumlah bit eksponen dalam format presisi lebih rendah
mantissa_bits	int32	jumlah bit mantissa dalam format presisi lebih rendah

Hasilnya adalah array jenis T. Nilai input dibulatkan ke nilai terdekat yang dapat diwakili dengan jumlah bit mantissa yang ditentukan (menggunakan semantik "ikatan ke genap"), dan setiap nilai yang melebihi rentang yang ditentukan oleh jumlah bit eksponen akan dibulatkan ke tak terhingga positif atau negatif. Nilai NaN akan dipertahankan, meskipun dapat dikonversi menjadi nilai NaN kanonis.

Format presisi lebih rendah harus memiliki minimal satu bit eksponen (untuk membedakan nilai nol dari tak terhingga, karena keduanya memiliki mantisa nol), dan harus memiliki jumlah bit mantisa yang bukan negatif. Jumlah bit eksponen atau mantissa dapat melebihi nilai yang sesuai untuk jenis T; bagian konversi yang sesuai kemudian akan dianggap tanpa pengoperasian.

ReduceScatter

Lihat juga XlaBuilder::ReduceScatter.

KurangiScatter adalah operasi kolektif yang secara efektif melakukan AllReduce, kemudian menyebarkan hasilnya dengan membaginya menjadi blok shard_count di sepanjang scatter_dimension dan replika i dalam grup replika menerima shard ith.

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

Argumen	Jenis	Semantik
operand	XlaOp	Array atau tuple array yang tidak kosong untuk dikurangi di seluruh replika.
computation	XlaComputation	Komputasi pengurangan
scatter_dimension	int64	Dimensi untuk sebar.
shard_count	int64	Jumlah blok untuk memisahkan scatter_dimension
replica_groups	vektor int64	Grup tempat pengurangan dilakukan
channel_id	int64 opsional	ID saluran opsional untuk komunikasi lintas modul

• Jika operand adalah tuple array, reduce-scatter akan dilakukan pada setiap elemen tuple.
• replica_groups adalah daftar grup replika tempat pengurangan dilakukan (ID replika untuk replika saat ini dapat diambil menggunakan ReplicaId). Urutan replika di setiap grup menentukan urutan penyebaran hasil all-reduce. replica_groups harus kosong (dalam hal ini, semua replika termasuk dalam satu grup), atau berisi jumlah elemen yang sama dengan jumlah replika. Jika ada lebih dari satu grup replika, semuanya harus berukuran sama. Misalnya, replica_groups = {0, 2}, {1, 3} melakukan pengurangan antara replika 0 dan 2, serta 1 dan 3, lalu menyebarkan hasilnya.
• shard_count adalah ukuran setiap grup replika. Kita memerlukannya jika replica_groups kosong. Jika replica_groups tidak kosong, shard_count harus sama dengan ukuran setiap grup replika.
• channel_id digunakan untuk komunikasi lintas modul: hanya operasi reduce-scatter dengan channel_id yang sama yang dapat berkomunikasi satu sama lain.

Bentuk output adalah bentuk input dengan scatter_dimension yang dibuat shard_count kali lebih kecil. Misalnya, jika ada dua replika dan operand masing-masing memiliki nilai [1.0, 2.25] dan [3.0, 5.25] pada dua replika, nilai output dari operasi ini dengan scatter_dim adalah 0 akan menjadi [4.0] untuk replika pertama dan [7.5] untuk replika kedua.

ReduceWindow

Lihat juga XlaBuilder::ReduceWindow.

Menerapkan fungsi pengurangan ke semua elemen di setiap jendela urutan array multidimensi N, menghasilkan satu atau tuple array multidimensi N sebagai output. Setiap array output memiliki jumlah elemen yang sama dengan jumlah posisi jendela yang valid. Lapisan penggabungan dapat dinyatakan sebagai ReduceWindow. Serupa dengan Reduce, computation yang diterapkan selalu meneruskan init_values di sebelah kiri.

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

Argumen	Jenis	Semantik
operands	N XlaOps	Urutan array multi-dimensi N dari jenis T_0,..., T_{N-1}, masing-masing mewakili area dasar tempat jendela ditempatkan.
init_values	N XlaOps	N nilai awal untuk pengurangan, satu untuk setiap N operand. Lihat Mengurangi untuk mengetahui detailnya.
computation	XlaComputation	Fungsi pengurangan jenis T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1}), untuk diterapkan ke elemen di setiap jendela dari semua operand input.
window_dimensions	ArraySlice<int64>	array bilangan bulat untuk nilai dimensi jendela
window_strides	ArraySlice<int64>	array bilangan bulat untuk nilai langkah jendela
base_dilations	ArraySlice<int64>	array bilangan bulat untuk nilai dilatasi dasar
window_dilations	ArraySlice<int64>	array bilangan bulat untuk nilai dilatasi jendela
padding	Padding	jenis padding untuk jendela (Padding::kSame, yang menjadi bantalan sehingga memiliki bentuk output yang sama dengan input jika langkahnya adalah 1, atau Padding::kValid, yang tidak menggunakan padding dan "menghentikan" jendela setelah tidak lagi pas)

Dengan keterangan:

• N harus lebih besar dari atau sama dengan 1.
• Semua array input harus memiliki dimensi yang sama.
• Jika N = 1, Collate(T) adalah T.
• Jika N > 1, Collate(T_0, ..., T_{N-1}) adalah tuple elemen N dari jenis (T0,...T{N-1}).

Kode dan gambar di bawah menunjukkan contoh penggunaan ReduceWindow. Input adalah matriks berukuran [4x6] dan window_dimensions dan window_stride_dimensions adalah [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);

Langkah 1 dalam dimensi menentukan bahwa posisi jendela dalam dimensi berjarak 1 elemen dari jendela yang berdekatan. Untuk menentukan bahwa tidak ada jendela yang tumpang-tindih, window_stride_dimensions harus sama dengan window_dimensions. Gambar di bawah mengilustrasikan penggunaan dua nilai langkah yang berbeda. Padding diterapkan ke setiap dimensi input dan penghitungannya sama seperti input yang masuk dengan dimensi yang dimilikinya setelah padding.

Untuk contoh padding non-trivial, pertimbangkan untuk menghitung minimum jendela pengurangan (nilai awal adalah MAX_FLOAT) dengan dimensi 3 dan langkah 2 di atas array input [10000, 1000, 100, 10, 1]. Padding kValid menghitung minimum selama dua jendela valid: [10000, 1000, 100] dan [100, 10, 1], yang menghasilkan output [100, 1]. Padding kSame pertama-tama akan mengisi array sehingga bentuknya setelah reduce-window akan sama dengan input untuk langkah satu dengan menambahkan elemen awal di kedua sisi, sehingga mendapatkan [MAX_VALUE, 10000, 1000, 100, 10, 1, MAX_VALUE]. Menjalankan reduce-window pada array yang dipadding beroperasi pada tiga jendela [MAX_VALUE, 10000, 1000], [1000, 100, 10], [10, 1, MAX_VALUE], dan menghasilkan [1000, 10, 1].

Urutan evaluasi fungsi pengurangan bersifat arbitrer dan mungkin non-deterministik. Oleh karena itu, fungsi reduksi tidak boleh terlalu sensitif terhadap pengaitan ulang. Lihat diskusi tentang asosiatif dalam konteks Reduce untuk mengetahui detail selengkapnya.

ReplicaId

Lihat juga XlaBuilder::ReplicaId.

Menampilkan ID unik (skalar U32) replika.

ReplicaId()

ID unik setiap replika adalah bilangan bulat tanpa tanda tangan dalam interval [0, N), dengan N adalah jumlah replika. Karena semua replika menjalankan program yang sama, panggilan ReplicaId() dalam program akan menampilkan nilai yang berbeda di setiap replika.

Pembentukan ulang

Lihat juga XlaBuilder::Reshape dan operasi Collapse.

Membentuk ulang dimensi array menjadi konfigurasi baru.

Reshape(operand, new_sizes) Reshape(operand, dimensions, new_sizes)

Argumen	Jenis	Semantik
operand	XlaOp	array jenis T
dimensions	Vektor int64	urutan dimensi diciutkan
new_sizes	Vektor int64	vektor ukuran dimensi baru

Secara konseptual, reshape pertama-tama meratakan array menjadi vektor satu dimensi dari nilai data, lalu menyempurnakan vektor ini menjadi bentuk baru. Argumen input adalah array arbitrer jenis T, vektor konstanta waktu kompilasi dari indeks dimensi, dan vektor ukuran dimensi yang konstan waktu kompilasi untuk hasilnya. Nilai dalam vektor dimension, jika diberikan, harus berupa permutasi dari semua dimensi T; nilai default jika tidak diberikan adalah {0, ..., rank - 1}. Urutan dimensi di dimensions adalah dari dimensi yang bervariasi paling lambat (paling utama) hingga dimensi yang bervariasi paling cepat (paling minor) dalam loop nest yang menggabungkan array input menjadi satu dimensi. Vektor new_sizes menentukan ukuran array output. Nilai pada indeks 0 di new_sizes adalah ukuran dimensi 0, nilai pada indeks 1 adalah ukuran dimensi 1, dan seterusnya. Hasil dimensi new_size harus sama dengan hasil ukuran dimensi operand. Saat menyaring array yang diciutkan menjadi array multidimensi yang ditentukan oleh new_sizes, dimensi di new_sizes diurutkan dari variasi paling lambat (paling besar) hingga variasi tercepat (paling kecil).

Misalnya, anggap v adalah array yang berisi 24 elemen:

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

Sebagai kasus khusus, reshape dapat mengubah array satu elemen menjadi skalar dan sebaliknya. Misalnya,

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

Rev (terbalik)

Lihat juga XlaBuilder::Rev.

Rev(operand, dimensions)

Argumen	Jenis	Semantik
operand	XlaOp	array jenis T
dimensions	ArraySlice<int64>	dimensi untuk dikembalikan

Membalik urutan elemen dalam array operand di sepanjang dimensions yang ditentukan, menghasilkan array output dengan bentuk yang sama. Setiap elemen array operand pada indeks multidimensi disimpan ke dalam array output pada indeks yang ditransformasi. Indeks multidimensi ditransformasi dengan membalik indeks di setiap dimensi agar dibalik (yaitu, jika dimensi ukuran N adalah salah satu dimensi pembalik, indeks i diubah menjadi N - 1 - i).

Salah satu kegunaan operasi Rev adalah membalikkan array bobot konvolusi di sepanjang dua dimensi jendela selama komputasi gradien di jaringan neural.

RngNormal

Lihat juga XlaBuilder::RngNormal.

Membuat output dari bentuk tertentu dengan angka acak yang dihasilkan mengikuti \(N(\mu, \sigma)\) distribusi normal. Parameter \(\mu\) dan \(\sigma\), serta bentuk output harus memiliki jenis elemen floating point. Selain itu, parameter harus berupa nilai skalar.

RngNormal(mu, sigma, shape)

Argumen	Jenis	Semantik
mu	XlaOp	Skalar tipe T yang menentukan rata-rata angka yang dihasilkan
sigma	XlaOp	Skalar tipe T yang menentukan standar deviasi dari output
shape	Shape	Bentuk output dari jenis T

RngUniform

Lihat juga XlaBuilder::RngUniform.

Membuat output bentuk tertentu dengan angka acak yang dihasilkan mengikuti distribusi seragam selama interval \([a,b)\). Jenis parameter dan elemen output harus berupa jenis boolean, jenis integral, atau jenis floating point, dan jenisnya harus konsisten. Backend CPU dan GPU saat ini hanya mendukung F64, F32, F16, BF16, S64, U64, S32, dan U32. Selain itu, parameter harus bernilai skalar. Jika \(b <= a\) hasilnya adalah ditentukan oleh implementasi.

RngUniform(a, b, shape)

Argumen	Jenis	Semantik
a	XlaOp	Skalar jenis T yang menentukan batas bawah interval
b	XlaOp	Skalar tipe T yang menentukan batas atas interval
shape	Shape	Bentuk output jenis T

RngBitGenerator

Menghasilkan output dengan bentuk tertentu yang diisi dengan bit acak seragam menggunakan algoritma yang ditentukan (atau default backend) dan menampilkan status yang diperbarui (dengan bentuk yang sama dengan status awal) serta data acak yang dihasilkan.

Status awal adalah status awal pembuatan angka acak saat ini. Nilai ini dan bentuk yang diperlukan serta nilai yang valid bergantung pada algoritma yang digunakan.

Output dijamin merupakan fungsi deterministik dari status awal, tetapi tidak dijamin deterministik antara backend dan versi compiler yang berbeda.

RngBitGenerator(algorithm, key, shape)

Argumen	Jenis	Semantik
algorithm	RandomAlgorithm	Algoritma PRNG yang akan digunakan.
initial_state	XlaOp	Status awal untuk algoritma PRNG.
shape	Shape	Bentuk output untuk data yang dihasilkan.

Nilai yang tersedia untuk algorithm:

• rng_default: Algoritma khusus backend dengan persyaratan bentuk khusus backend.

• rng_three_fry: Algoritma PRNG berbasis penghitung ThreeFry. Bentuk initial_state adalah u64[2] dengan nilai arbitrer. Salmon et al. SC 2011. Angka acak paralel: semudah 1, 2, 3.

• rng_philox: Algoritme Philox untuk menghasilkan angka acak secara paralel. Bentuk initial_state adalah u64[3] dengan nilai arbitrer. Salmon et al. SC 2011. Angka acak paralel: semudah 1, 2, 3.

Sebar

Operasi sebar XLA menghasilkan urutan hasil yang merupakan nilai array input operands, dengan beberapa irisan (pada indeks yang ditentukan oleh scatter_indices) yang diperbarui dengan urutan nilai dalam updates menggunakan update_computation.

Lihat juga XlaBuilder::Scatter.

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

Argumen	Jenis	Semantik
operands	Urutan N XlaOp	N array jenis T_0, ..., T_N yang akan disebar.
scatter_indices	XlaOp	Array yang berisi indeks awal slice yang harus disebar.
updates	Urutan N XlaOp	Array N dari jenis T_0, ..., T_N. updates[i] berisi nilai yang harus digunakan untuk menyebarkan operands[i].
update_computation	XlaComputation	Komputasi yang akan digunakan untuk menggabungkan nilai yang ada dalam array input dan update selama penyebaran. Komputasi ini harus berjenis T_0, ..., T_N, T_0, ..., T_N -> Collate(T_0, ..., T_N).
index_vector_dim	int64	Dimensi dalam scatter_indices yang berisi indeks awal.
update_window_dims	ArraySlice<int64>	Kumpulan dimensi dalam bentuk updates yang merupakan dimensi jendela.
inserted_window_dims	ArraySlice<int64>	Kumpulan dimensi jendela yang harus disisipkan ke dalam bentuk updates.
scatter_dims_to_operand_dims	ArraySlice<int64>	Peta dimensi dari indeks sebar ke ruang indeks operand. Array ini ditafsirkan sebagai pemetaan i ke scatter_dims_to_operand_dims[i]. Harus satu per satu dan total.
indices_are_sorted	bool	Apakah indeks dijamin diurutkan oleh pemanggil.
unique_indices	bool	Apakah indeks dijamin unik oleh pemanggil.

Dengan keterangan:

• N harus lebih besar dari atau sama dengan 1.
• operands[0], ..., operands[N-1] harus memiliki dimensi yang sama.
• updates[0], ..., updates[N-1] harus memiliki dimensi yang sama.
• Jika N = 1, Collate(T) adalah T.
• Jika N > 1, Collate(T_0, ..., T_N) adalah tuple elemen N dari jenis T.

Jika index_vector_dim sama dengan scatter_indices.rank, kami secara implisit menganggap scatter_indices memiliki dimensi 1 di akhir.

Kami menentukan update_scatter_dims dari jenis ArraySlice<int64> sebagai kumpulan dimensi dalam bentuk updates yang tidak dalam update_window_dims, dalam urutan menaik.

Argumen sebar harus mengikuti batasan berikut:

• Setiap array updates harus memiliki peringkat update_window_dims.size + scatter_indices.rank - 1.

• Batas dimensi i di setiap array updates harus sesuai dengan hal berikut:

  • Jika i ada di update_window_dims (yaitu sama dengan update_window_dims[k] untuk beberapa k), batas dimensi i di updates tidak boleh melebihi batas operand yang sesuai setelah mempertimbangkan inserted_window_dims (yaitu adjusted_window_bounds[k], dengan adjusted_window_bounds berisi batas operand dengan batas pada indeks inserted_window_dims dihapus).
  • Jika i ada di update_scatter_dims (yaitu sama dengan update_scatter_dims[k] untuk beberapa k), batas dimensi i di updates harus sama dengan batas scatter_indices yang sesuai, dengan melewati index_vector_dim (yaitu scatter_indices.shape.dims[k], jika k < index_vector_dim dan scatter_indices.shape.dims[k+1] jika tidak).

• update_window_dims harus dalam urutan menaik, tidak memiliki angka dimensi berulang, dan berada dalam rentang [0, updates.rank).

• inserted_window_dims harus dalam urutan menaik, tidak memiliki nomor dimensi yang berulang, dan berada dalam rentang [0, operand.rank).

• operand.rank harus sama dengan jumlah update_window_dims.size dan inserted_window_dims.size.

• scatter_dims_to_operand_dims.size harus sama dengan scatter_indices.shape.dims[index_vector_dim], dan nilainya harus dalam rentang [0, operand.rank).

Untuk indeks tertentu U di setiap array updates, indeks I yang sesuai dalam array operands yang sesuai tempat pembaruan ini diterapkan dihitung sebagai berikut:

1. Misalkan G = { U[k] untuk k di update_scatter_dims }. Gunakan G untuk mencari vektor indeks S dalam array scatter_indices sehingga S[i] = scatter_indices[Combine(G, i)] dengan Combine(A, b) menyisipkan b pada posisi index_vector_dim ke dalam A.
2. Buat indeks Sin ke operand menggunakan S dengan menyebarkan S menggunakan peta scatter_dims_to_operand_dims. Secara lebih formal:
   1. Sin[scatter_dims_to_operand_dims[k]] = S[k] jika k < scatter_dims_to_operand_dims.size.
   2. Sin[_] = 0.
3. Buat indeks Win ke dalam setiap array operands dengan menyebarkan indeks di update_window_dims dalam U sesuai dengan inserted_window_dims. Secara lebih formal:
   1. Win[window_dims_to_operand_dims(k)] = U[k] jika k ada di update_window_dims, dengan window_dims_to_operand_dims adalah fungsi monoton dengan domain [0, update_window_dims.size) dan rentang [0, operand.rank) \ inserted_window_dims. (Misalnya, jika update_window_dims.size adalah 4, operand.rank adalah 6, dan inserted_window_dims adalah {0, 2}, maka window_dims_to_operand_dims adalah {0→1, 1→3, 2→4, 3→5}).
   2. Win[_] = 0.
4. I adalah Win + Sin dengan + adalah penjumlahan berbasis elemen.

Singkatnya, operasi penyebaran dapat ditentukan sebagai berikut.

• Lakukan inisialisasi output dengan operands, yaitu untuk semua indeks J, untuk semua indeks O di array operands[J]:
  output[J][O] = operands[J][O]
• Untuk setiap indeks U di array updates[J] dan indeks yang sesuai O dalam array operand[J], jika O adalah indeks yang valid untuk output:
  (output[0][O], ..., output[N-1][O]) =update_computation(output[0][O], ..., ,output[N-1][O],updates[0][U], ...,updates[N-1][U])

Urutan penerapan update bersifat non-deterministik. Jadi, jika beberapa indeks di updates merujuk ke indeks yang sama di operands, nilai yang sesuai di output akan bersifat non-deterministik.

Perlu diperhatikan bahwa parameter pertama yang diteruskan ke update_computation akan selalu menjadi nilai saat ini dari array output dan parameter kedua akan selalu menjadi nilai dari array updates. Hal ini penting khusus untuk kasus saat update_computation tidak komutatif.

Jika indices_are_sorted ditetapkan ke true, XLA dapat mengasumsikan bahwa scatter_indices diurutkan (dalam urutan menaik, setelah menyebarkan nilainya sesuai dengan scatter_dims_to_operand_dims) oleh pengguna. Jika tidak, semantik ditentukan oleh implementasi.

Jika unique_indices ditetapkan ke benar (true), XLA dapat mengasumsikan bahwa semua elemen yang tersebar bersifat unik. Jadi XLA bisa menggunakan operasi non-atomik. Jika unique_indices disetel ke benar (true) dan indeks yang disebar tidak unik, semantik ditentukan oleh implementasi.

Secara informal, operasi scatter dapat dilihat sebagai invers dari operasi gather, yaitu operasi scatter memperbarui elemen dalam input yang diekstrak oleh operasi gather yang sesuai.

Untuk deskripsi informal dan contoh mendetail, lihat bagian "Deskripsi Informal" di bagian Gather.

Pilih

Lihat juga XlaBuilder::Select.

Membuat array output dari elemen dua array input, berdasarkan nilai array predikat.

Select(pred, on_true, on_false)

Argumen	Jenis	Semantik
pred	XlaOp	array jenis PRED
on_true	XlaOp	array tipe T
on_false	XlaOp	array jenis T

Array on_true dan on_false harus memiliki bentuk yang sama. Ini juga merupakan bentuk array output. Array pred harus memiliki dimensi yang sama dengan on_true dan on_false, dengan jenis elemen PRED.

Untuk setiap elemen P dari pred, elemen array output yang sesuai diambil dari on_true jika nilai P adalah true, dan dari on_false jika nilai P adalah false. Sebagai bentuk penyiaran yang dibatasi, pred dapat menjadi skalar dari jenis PRED. Dalam hal ini, array output diambil seluruhnya dari on_true jika pred adalah true, dan dari on_false jika pred adalah false.

Contoh dengan pred non-skalar:

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

Contoh dengan pred skalar:

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

Pilihan di antara tuple didukung. Tuple dianggap sebagai jenis skalar untuk tujuan ini. Jika on_true dan on_false adalah tuple (yang harus memiliki bentuk yang sama), pred harus berupa skalar dari jenis PRED.

SelectAndScatter

Lihat juga XlaBuilder::SelectAndScatter.

Operasi ini dapat dianggap sebagai operasi gabungan yang pertama kali menghitung ReduceWindow pada array operand untuk memilih elemen dari setiap jendela, lalu mendistribusikan array source ke indeks elemen yang dipilih untuk membuat array output dengan bentuk yang sama seperti array operand. Fungsi select biner digunakan untuk memilih elemen dari setiap jendela dengan menerapkannya di setiap jendela, dan dipanggil dengan properti bahwa vektor indeks parameter pertama secara leksikografis kurang dari vektor indeks parameter kedua. Fungsi select menampilkan true jika parameter pertama dipilih dan menampilkan false jika parameter kedua dipilih, dan fungsi harus mempertahankan transitivitas (yaitu, jika select(a, b) dan select(b, c) adalah true, maka select(a, c) juga true) sehingga elemen yang dipilih tidak bergantung pada urutan elemen yang dilalui untuk jendela tertentu.

Fungsi scatter diterapkan pada setiap indeks yang dipilih dalam array output. Fungsi ini memerlukan dua parameter skalar:

1. Nilai saat ini pada indeks yang dipilih dalam array output
2. Nilai sebaran dari source yang berlaku untuk indeks yang dipilih

Fungsi ini menggabungkan dua parameter dan menampilkan nilai skalar yang digunakan untuk memperbarui nilai pada indeks yang dipilih dalam array output. Awalnya, semua indeks array output ditetapkan ke init_value.

Array output memiliki bentuk yang sama dengan array operand dan array source harus memiliki bentuk yang sama dengan hasil penerapan operasi ReduceWindow pada array operand. SelectAndScatter dapat digunakan untuk melakukan backpropagation nilai gradien untuk lapisan penggabungan dalam jaringan saraf.

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

Argumen	Jenis	Semantik
operand	XlaOp	array jenis T yang menjadi tempat jendela bergeser
select	XlaComputation	komputasi biner jenis T, T -> PRED, untuk diterapkan ke semua elemen di setiap jendela; menampilkan true jika parameter pertama dipilih dan menampilkan false jika parameter kedua dipilih
window_dimensions	ArraySlice<int64>	array bilangan bulat untuk nilai dimensi jendela
window_strides	ArraySlice<int64>	array bilangan bulat untuk nilai langkah jendela
padding	Padding	jenis padding untuk window (Padding::kSame atau Padding::kValid)
source	XlaOp	array jenis T dengan nilai yang akan disebar
init_value	XlaOp	nilai skalar tipe T untuk nilai awal larik output
scatter	XlaComputation	komputasi biner jenis T, T -> T, untuk menerapkan setiap elemen sumber sebaran dengan elemen tujuannya

Gambar di bawah menunjukkan contoh penggunaan SelectAndScatter, dengan fungsi select menghitung nilai maksimum di antara parameternya. Perhatikan bahwa saat jendela tumpang-tindih, seperti pada gambar (2) di bawah, indeks array operand dapat dipilih beberapa kali oleh jendela yang berbeda. Pada gambar, elemen nilai 9 dipilih oleh kedua jendela atas (biru dan merah) dan fungsi penambahan biner scatter menghasilkan elemen output dengan nilai 8 (2 + 6).

Urutan evaluasi fungsi scatter bersifat arbitrer dan mungkin non-deterministik. Oleh karena itu, fungsi scatter tidak boleh terlalu sensitif terhadap pengaitan ulang. Lihat diskusi tentang asosiatif dalam konteks Reduce untuk mengetahui detail selengkapnya.

Kirim

Lihat juga XlaBuilder::Send.

Send(operand, channel_handle)

Argumen	Jenis	Semantik
operand	XlaOp	data yang akan dikirim (array tipe T)
channel_handle	ChannelHandle	ID unik untuk setiap pasangan pengiriman/penerimaan

Mengirim data operand yang diberikan ke petunjuk Recv dalam komputasi lain yang memiliki handle saluran yang sama. Tidak menampilkan data apa pun.

Serupa dengan operasi Recv, API klien dari operasi Send mewakili komunikasi sinkron, dan secara internal diuraikan menjadi 2 petunjuk HLO (Send dan SendDone) untuk mengaktifkan transfer data asinkron. Lihat juga HloInstruction::CreateSend dan HloInstruction::CreateSendDone.

Send(HloInstruction operand, int64 channel_id)

Memulai transfer asinkron operand ke resource yang dialokasikan oleh petunjuk Recv dengan ID saluran yang sama. Menampilkan konteks, yang digunakan oleh instruksi SendDone berikut untuk menunggu hingga transfer data selesai. Konteksnya adalah tuple dari {operand (shape), request identifier (U32)} dan hanya dapat digunakan oleh petunjuk SendDone.

SendDone(HloInstruction context)

Dengan mempertimbangkan konteks yang dibuat oleh instruksi Send, proses ini akan menunggu transfer data selesai. Petunjuk tidak menampilkan data apa pun.

Penjadwalan petunjuk saluran

Urutan eksekusi 4 petunjuk untuk setiap saluran (Recv, RecvDone, Send, SendDone) adalah seperti di bawah ini.

• Recv terjadi sebelum Send
• Send terjadi sebelum RecvDone
• Recv terjadi sebelum RecvDone
• Send terjadi sebelum SendDone

Saat compiler backend membuat jadwal linear untuk setiap komputasi yang berkomunikasi melalui petunjuk saluran, tidak boleh ada siklus di seluruh komputasi. Misalnya, jadwal di bawah menyebabkan deadlock.

Slice

Lihat juga XlaBuilder::Slice.

Pemotongan mengekstrak sub-array dari array input. Sub-array memiliki peringkat yang sama dengan input dan berisi nilai di dalam kotak pembatas dalam array input tempat dimensi dan indeks kotak pembatas diberikan sebagai argumen ke operasi slice.

Slice(operand, start_indices, limit_indices, strides)

Argumen	Jenis	Semantik
operand	XlaOp	Array dimensi N dari jenis T
start_indices	ArraySlice<int64>	Daftar bilangan bulat N yang berisi indeks awal slice untuk setiap dimensi. Nilai harus lebih besar dari atau sama dengan nol.
limit_indices	ArraySlice<int64>	Daftar bilangan bulat N yang berisi indeks akhir (eksklusif) untuk irisan bagi setiap dimensi. Setiap nilai harus lebih besar dari atau sama dengan nilai start_indices masing-masing untuk dimensi dan kurang dari atau sama dengan ukuran dimensi.
strides	ArraySlice<int64>	Daftar bilangan bulat N yang menentukan stride input slice. Slice memilih setiap elemen strides[d] dalam dimensi d.

Contoh 1 dimensi:

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
Slice(a, {2}, {4}) produces:
  {2.0, 3.0}

Contoh 2 dimensi:

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

Urutkan

Lihat juga XlaBuilder::Sort.

Sort(operands, comparator, dimension, is_stable)

Argumen	Jenis	Semantik
operands	ArraySlice<XlaOp>	Operand untuk mengurutkan.
comparator	XlaComputation	Komputasi pembanding yang akan digunakan.
dimension	int64	Dimensi yang akan diurutkan.
is_stable	bool	Apakah penyortiran yang stabil harus digunakan.

Jika hanya satu operand yang diberikan:

• Jika operand adalah tensor peringkat 1 (array), hasilnya adalah array yang diurutkan. Jika Anda ingin mengurutkan array dalam urutan menaik, pembanding harus melakukan perbandingan kurang dari. Secara formal, setelah diurutkan, array akan menyimpan untuk semua posisi indeks i, j dengan i < j yang comparator(value[i], value[j]) = comparator(value[j], value[i]) = false atau comparator(value[i], value[j]) = true.

• Jika operand memiliki peringkat yang lebih tinggi, operand akan diurutkan berdasarkan dimensi yang disediakan. Misalnya, untuk tensor peringkat 2 (matriks), nilai dimensi 0 akan mengurutkan setiap kolom secara independen, dan nilai dimensi 1 akan mengurutkan setiap baris secara independen. Jika tidak ada nomor dimensi yang diberikan, dimensi terakhir akan dipilih secara default. Untuk dimensi yang diurutkan, urutan pengurutan yang sama akan berlaku seperti dalam kasus peringkat-1.

Jika operand n > 1 diberikan:

• Semua operand n harus berupa tensor dengan dimensi yang sama. Jenis elemen tensor mungkin berbeda.

• Semua operand diurutkan bersama, bukan satu per satu. Secara konseptual, operand diperlakukan sebagai tuple. Saat memeriksa apakah elemen dari setiap operand pada posisi indeks i dan j perlu ditukar, pembanding dipanggil dengan parameter skalar 2 * n, dengan parameter 2 * k sesuai dengan nilai pada posisi i dari operand k-th, dan parameter 2 * k + 1 sesuai dengan nilai pada posisi j dari operand k-th. Biasanya, pembanding akan membandingkan parameter 2 * k dan 2 * k + 1 satu sama lain dan mungkin menggunakan pasangan parameter lain sebagai pemecah seri.

• Hasilnya adalah tuple yang terdiri dari operand dalam urutan yang diurutkan (bersama dimensi yang disediakan, seperti di atas). Operand i-th tuple sesuai dengan operand i-th Sort.

Misalnya, jika ada tiga operand operand0 = [3, 1], operand1 = [42, 50], operand2 = [-3.0, 1.1], dan pembanding hanya membandingkan nilai operand0 dengan kurang dari, output pengurutan adalah tuple ([1, 3], [50, 42], [1.1, -3.0]).

Jika is_stable disetel ke benar (true), pengurutan dijamin stabil, yaitu, jika ada elemen yang dianggap sama oleh pembanding, urutan relatif dari nilai yang sama akan dipertahankan. Dua elemen e1 dan e2 sama jika dan hanya jika comparator(e1, e2) = comparator(e2, e1) = false. Secara default, is_stable ditetapkan ke salah (false).

Transpose

Lihat juga operasi tf.reshape.

Transpose(operand)

Argumen	Jenis	Semantik
operand	XlaOp	Operand yang akan ditransposisi.
permutation	ArraySlice<int64>	Cara melakukan permutasi dimensi.

Mengurutkan ulang dimensi operand dengan permutasi yang diberikan, sehingga ∀ i . 0 ≤ i < rank ⇒ input_dimensions[permutation[i]] = output_dimensions[i].

Ini sama dengan Reshape(operand, permutation, Permute(permutation, operand.shape.dimensions)).

TriangularSolve

Lihat juga XlaBuilder::TriangularSolve.

Menyelesaikan sistem persamaan linear dengan matriks koefisien segitiga bawah atau atas dengan substitusi maju atau mundur. Dengan menyiarkan di sepanjang dimensi utama, rutinitas ini akan menyelesaikan salah satu sistem matriks op(a) * x = b, atau x * op(a) = b, untuk variabel x, dengan a dan b, dengan op(a) adalah op(a) = a, atau op(a) = Transpose(a), atau op(a) = Conj(Transpose(a)).

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

Argumen	Jenis	Semantik
a	XlaOp	array dengan peringkat > 2 dari jenis kompleks atau floating point dengan bentuk [..., M, M].
b	XlaOp	array dengan peringkat > 2 dari jenis yang sama dengan bentuk [..., M, K] jika left_side bernilai benar, [..., K, M] jika tidak.
left_side	bool	menunjukkan apakah akan menyelesaikan sistem formulir op(a) * x = b (true) atau x * op(a) = b (false).
lower	bool	apakah akan menggunakan segitiga atas atau bawah a.
unit_diagonal	bool	jika true, elemen diagonal a diasumsikan sebagai 1 dan tidak diakses.
transpose_a	Transpose	apakah akan menggunakan a sebagaimana adanya, melakukan transposisi atau mengambil transposisi konjugasinya.

Data input hanya dibaca dari segitiga bawah/atas a, bergantung pada nilai lower. Nilai dari segitiga lainnya akan diabaikan. Data output ditampilkan dalam segitiga yang sama; nilai dalam segitiga lainnya ditentukan oleh implementasi dan dapat berupa apa saja.

Jika peringkat a dan b lebih besar dari 2, keduanya akan diperlakukan sebagai batch matriks, dengan semua kecuali dimensi minor 2 adalah dimensi batch. a dan b harus memiliki dimensi batch yang sama.

Tuple

Lihat juga XlaBuilder::Tuple.

Tuple yang berisi nomor variabel tuas data, yang masing-masing memiliki bentuk sendiri.

Hal ini analog dengan std::tuple di C++. Secara konseptual:

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

Tuple dapat didekonstruksi (diakses) melalui operasi GetTupleElement.

Meskipun

Lihat juga XlaBuilder::While.

While(condition, body, init)

Argumen	Jenis	Semantik
condition	XlaComputation	XlaComputation jenis T -> PRED yang menentukan kondisi penghentian loop.
body	XlaComputation	XlaComputation dari jenis T -> T yang menentukan isi loop.
init	T	Nilai awal untuk parameter condition dan body.

Secara berurutan mengeksekusi body hingga condition gagal. Ini mirip dengan while loop biasa di banyak bahasa lain, kecuali untuk perbedaan dan batasan yang tercantum di bawah.

• Node While menampilkan nilai jenis T, yang merupakan hasil dari eksekusi terakhir body.
• Bentuk dari jenis T ditentukan secara statis dan harus sama di semua iterasi.

Parameter T komputasi diinisialisasi dengan nilai init dalam iterasi pertama dan otomatis diperbarui ke hasil baru dari body di setiap iterasi berikutnya.

Salah satu kasus penggunaan utama node While adalah menerapkan eksekusi berulang pelatihan dalam jaringan saraf. Pseudocode yang disederhanakan ditampilkan di bawah dengan grafik yang mewakili komputasi. Kode ini dapat ditemukan di while_test.cc. Jenis T dalam contoh ini adalah Tuple yang terdiri dari int32 untuk jumlah iterasi dan vector[10] untuk akumulator. Untuk 1.000 iterasi, loop terus menambahkan vektor konstan ke akumulator.

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