Semantik operasi

Berikut ini menjelaskan semantik operasi yang ditentukan dalam antarmuka XlaBuilder. Biasanya, operasi ini memetakan satu per satu ke operasi yang ditentukan dalam antarmuka RPC di xla_data.proto.

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

AfterAll

Lihat juga XlaBuilder::AfterAll.

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

AfterAll(operands)

Arguments	Jenis	Semantik
operands	XlaOp	jumlah token (variadic number)

AllGather

Lihat juga XlaBuilder::AllGather.

Melakukan penggabungan di seluruh replika.

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

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

• replica_groups adalah daftar grup replika tempat penggabungan dilakukan (ID replika untuk replika saat ini dapat diambil menggunakan ReplicaId). Urutan replika di setiap grup menentukan urutan penempatan input dalam hasil. replica_groups harus kosong (dalam hal ini semua replika termasuk dalam satu grup, diurutkan dari 0 sampai 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 memerlukan ini jika replica_groups kosong.
• channel_id digunakan untuk komunikasi lintas modul: hanya operasi all-gather dengan channel_id yang sama yang dapat berkomunikasi satu sama lain.

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 kedua replika, maka nilai output dari op 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)

Arguments	Jenis	Semantik
operand	XlaOp	Array atau tuple array yang tidak kosong untuk dikurangi di seluruh replika
computation	XlaComputation	Komputasi pengurangan
replica_groups	vektor vektor int64	Grup di mana 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 (jika 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 berkomunikasi satu sama lain.

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 komputasi op dan penjumlahan ini akan menjadi [4.0, 7.75] di kedua replika. Jika inputnya adalah tuple, output-nya juga adalah tuple.

Menghitung hasil AllReduce memerlukan satu input dari setiap replika. Jadi, jika satu replika mengeksekusi node AllReduce lebih kali daripada yang lain, replika sebelumnya akan menunggu selamanya. Karena semua replika menjalankan program yang sama, tidak banyak cara untuk melakukannya. Namun, ada kemungkinan jika kondisi loop sementara bergantung pada data dari infeed dan data yang diberikan menyebabkan loop sementara melakukan iterasi lebih sering pada satu replika daripada replika lainnya.

AllToAll

Lihat juga XlaBuilder::AllToAll.

AllToAll adalah operasi kolektif yang mengirimkan data dari semua inti ke semua inti. Ini memiliki dua fase:

1. Fase pencar. Pada setiap inti, operand dibagi menjadi split_count blok di sepanjang split_dimensions, dan blok tersebar ke semua core, misalnya, blok ke-i dikirim ke inti ke-i.
2. Fase mengumpulkan. Setiap inti 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 sesuai urutan yang ditentukan. Misalnya, replica_groups = { {1,2,3}, {4,5,0} } berarti AllToAll akan diterapkan dalam replika {1, 2, 3}, dan dalam fase pengumpulan, dan blok yang diterima akan digabungkan dalam urutan yang sama, yaitu 1, 2, 3. Kemudian, AllToAll lain akan diterapkan dalam replika 4, 5, 0, dan urutan penggabungan juga 4, 5, 0. Jika replica_groups kosong, semua replika akan menjadi bagian dari satu grup, dalam urutan penggabungan tampilannya.

Prasyarat:

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

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

Arguments	Jenis	Semantik
operand	XlaOp	array input n dimensi
split_dimension	int64	Nilai dalam interval [0, n) yang menamai dimensi bersama operand yang dibagi
concat_dimension	int64	Nilai dalam [0, n) interval yang menamai dimensi dan blok pemisahan digabungkan
split_count	int64	Jumlah inti yang berpartisipasi dalam operasi ini. Jika replica_groups kosong, ini akan menunjukkan 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 menunjukkan 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 inti yang berpartisipasi dalam Alltoall. Pada setiap inti, Operand dibagi menjadi 4 bagian di sepanjang dimensi 0, sehingga setiap bagian memiliki bentuk f32[4,4]. Keempat bagian tersebut tersebar di semua inti. Kemudian setiap inti menyambungkan bagian-bagian yang diterima di sepanjang dimensi 1, dengan urutan inti 0-4. Jadi {i>output<i} pada setiap inti memiliki bentuk f32[16,4].

BatchNormGrad

Lihat juga XlaBuilder::BatchNormGrad dan kertas normalisasi batch asli untuk mengetahui deskripsi mendetail tentang algoritme.

Menghitung gradien norma tumpukan.

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

Arguments	Jenis	Semantik
operand	XlaOp	array dimensi n 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 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 memperhatikan operand, offset, dan scale di semua dimensi lainnya. feature_index harus berupa indeks yang valid untuk dimensi fitur di operand.

Ketiga gradien tersebut ditentukan oleh formula berikut (dengan asumsi array 4 dimensi sebagai operand dan dengan indeks dimensi fitur l, ukuran batch 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 merepresentasikan nilai momen di seluruh dimensi spasial dan batch.

Jenis outputnya adalah tuple dari tiga handle:

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

BatchNormInference

Lihat juga XlaBuilder::BatchNormInference dan kertas normalisasi batch asli untuk mengetahui deskripsi mendetail tentang algoritme.

Menormalkan array di seluruh dimensi spasial dan batch.

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

Arguments	Jenis	Semantik
operand	XlaOp	array n dimensi untuk 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 mean dan varians di semua dimensi lainnya serta menggunakan rata-rata dan varian untuk menormalisasi setiap elemen di operand. feature_index harus berupa indeks yang valid untuk dimensi fitur di operand.

BatchNormInference setara dengan memanggil BatchNormTraining tanpa menghitung mean dan variance untuk setiap batch. Diagram ini menggunakan input mean dan variance, sebagai gantinya, sebagai estimasi nilai. Tujuan dari operasi ini adalah untuk mengurangi latensi dalam inferensi, oleh karena itu diberi nama BatchNormInference.

Output-nya adalah array n-dimensi yang dinormalisasi dengan bentuk yang sama seperti operand input.

BatchNormTraining

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

Menormalkan array di seluruh dimensi spasial dan batch.

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

Arguments	Jenis	Semantik
operand	XlaOp	array dimensi n 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 tersebut menghitung mean dan varians di semua dimensi lainnya serta menggunakan rata-rata dan varian 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 tumpukan \(\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 varians 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$

• Menormalkan, 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 kesalahan pembagian dengan nol.

Jenis outputnya adalah tuple dari tiga XlaOp:

Output	Jenis	Semantik
output	XlaOp	array n dimensi 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 spasi dan batch menggunakan formula di atas.

BitcastConvertType

Lihat juga XlaBuilder::BitcastConvertType.

Mirip dengan tf.bitcast di TensorFlow, operasi bitcast berbasis 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)

Arguments	Jenis	Semantik
operand	XlaOp	array tipe T dengan redup D
new_element_type	PrimitiveType	tipe U

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

Jenis elemen sumber dan tujuan tidak boleh berupa tupel.

Mengonversi bitcast ke jenis primitif dengan lebar yang berbeda

Petunjuk HLO BitcastConvert mendukung kasus ketika 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 akan mendapatkan dimensi minor baru dari 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, instruksi mengharuskan dimensi logika terakhir dari bentuk input harus 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 lebar bit yang berbeda tidak bersifat elementwise.

Siarkan

Lihat juga XlaBuilder::Broadcast.

Menambahkan dimensi ke array dengan menduplikasi data dalam array.

Broadcast(operand, broadcast_sizes)

Arguments	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}, bentuk output memiliki dimensi {a0, ..., aN, b0, ..., bM}.

Indeks dimensi baru ke dalam salinan operand, yaitu

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

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

BroadcastInDim

Lihat juga XlaBuilder::BroadcastInDim.

Memperluas ukuran dan peringkat array dengan menduplikasi data dalam array.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

Arguments	Jenis	Semantik
operand	XlaOp	Array yang akan diduplikasi
out_dim_size	ArraySlice<int64>	Ukuran dimensi bentuk target
broadcast_dimensions	ArraySlice<int64>	Dimensi mana dalam target membentuk setiap dimensi yang sesuai dengan 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 i'th dari operand dipetakan ke dimensi 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. Penyiaran dimensi merosot, lalu menyiarkan di sepanjang dimensi yang merosot ini untuk mencapai bentuk output. Semantik dijelaskan secara mendetail di halaman penyiaran.

Panggilan Telepon

Lihat juga XlaBuilder::Call.

Memanggil komputasi dengan argumen yang diberikan.

Call(computation, args...)

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

Aritas dan jenis args harus cocok dengan parameter computation. args tidak boleh ada.

Cholesky

Lihat juga XlaBuilder::Cholesky.

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

Cholesky(a, lower)

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

Jika lower adalah true, menghitung matriks segitiga rendah l sehingga $a = l . l^T$. Jika lower adalah false, menghitung 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 lainnya akan diabaikan. Data output ditampilkan dalam segitiga yang sama; nilai dalam segitiga lainnya ditentukan oleh implementasi dan bisa berupa apa saja.

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

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

Penjepit

Lihat juga XlaBuilder::Clamp.

Mengunci operand ke dalam rentang antara nilai minimum dan maksimum.

Clamp(min, operand, max)

Arguments	Jenis	Semantik
min	XlaOp	array jenis T
operand	XlaOp	array jenis T
max	XlaOp	array jenis T

Dengan mempertimbangkan operand serta nilai minimum dan maksimum, tampilkan operand jika berada dalam rentang antara minimum dan maksimum. Jika tidak, akan 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 terbatas dari penyiaran, min dan/atau max dapat berupa skalar 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)

Arguments	Jenis	Semantik
operand	XlaOp	array jenis T
dimensions	Vektor int64	{i>subset<i} dimensi T yang berurutan dan berurutan.

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

Misalnya, biarkan v menjadi array dari 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)

Arguments	Jenis	Semantik
operand	XlaOp	array input n dimensi
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.

Perlu diketahui bahwa ada pembatasan berikut pada source_target_pair:

• 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, maka output pada replika tersebut adalah tensor yang terdiri dari 0 dengan bentuk yang sama dengan inputnya.

Gabungkan

Lihat juga XlaBuilder::ConcatInDim.

Menggabungkan array dari beberapa operand array. Array memiliki peringkat yang sama dengan setiap operand array input (yang harus memiliki peringkat yang sama satu sama lain) dan berisi argumen dalam urutan yang ditetapkan.

Concatenate(operands..., dimension)

Arguments	Jenis	Semantik
operands	urutan dari XlaOp	Array N jenis T dengan dimensi [L0, L1, ...]. Membutuhkan 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 menamai dimensi di mana 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},
}

{i>Diagram<i}:

Kondisional

Lihat juga XlaBuilder::Conditional.

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

Arguments	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 jenis \(T_1 \to S\)

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

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

Perlu diketahui bahwa hanya salah satu dari true_computation dan false_computation yang akan dieksekusi, bergantung pada nilai pred.

Conditional(branch_index, branch_computations, branch_operands)

Arguments	Jenis	Semantik
branch_index	XlaOp	Skalar jenis S32
branch_computations	urutan dari XlaComputation	XlaComputations jenis \(T_0 \to S , T_1 \to S , ..., T_{N-1} \to S\)
branch_operands	urutan dari 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] dieksekusi sebagai cabang default.

Setiap branch_computations[b] harus menggunakan satu argumen dari 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 dari branch_computations yang akan dieksekusi, bergantung pada nilai branch_index.

Konv. (konvolusi)

Lihat juga XlaBuilder::Conv.

Sebagai ConvWithGeneralPadding, tetapi padding ditentukan dengan cara singkat sebagai SAMA atau VALID. Padding yang SAMA menambahkan angka nol ke input (lhs) sehingga output memiliki bentuk yang sama dengan input jika tidak memperhitungkan striding. Padding VALID berarti tidak ada padding.

ConvWithGeneralPadding (konvolusi)

Lihat juga XlaBuilder::ConvWithGeneralPadding.

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

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

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

• batch: Setiap koordinat dalam dimensi ini mewakili input independen yang konvolusinya dilakukan.
• z/depth/features: Setiap posisi (y,x) di area dasar memiliki vektor yang terkait dengannya, yang masuk ke dalam 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/kernel/jendela konvolusional. Dimensinya adalah, dalam urutan ini:

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

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

Argumen padding menentukan jumlah padding nol yang akan diterapkan ke area dasar. Jumlah padding bisa bernilai 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 bawah, sedangkan padding tinggi diterapkan ke arah indeks yang lebih tinggi. Misalnya, jika padding[1] adalah (2,3), akan ada padding dengan 2 angka nol di sebelah kiri dan 3 angka nol di sebelah kanan pada dimensi spasial kedua. Menggunakan padding sama dengan memasukkan nilai nol yang sama ke dalam input (lhs) sebelum melakukan konvolusi.

Argumen lhs_dilation dan rhs_dilation menentukan faktor dilatasi yang akan diterapkan ke ikon dan rh, masing-masing, di setiap dimensi spasial. Jika faktor dilatasi dalam dimensi spasial adalah d, lubang d-1 secara implisit ditempatkan di antara setiap entri dalam dimensi tersebut, sehingga ukuran array akan meningkat. Lubang diisi dengan nilai tanpa pengoperasian, yang untuk konvolusi berarti nol.

Dilatasi rhs juga disebut konvolusi atrous. Untuk detail selengkapnya, lihat tf.nn.atrous_conv2d. Pelebaran tombol juga disebut konvolusi tertransposisi. 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 dari 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, setiap grup terdiri dari suburutan fitur yang berurutan. Dimensi fitur input rhs harus sama dengan dimensi fitur input lhs dibagi feature_group_count (sehingga sudah memiliki ukuran grup fitur input). Grup i-th digunakan bersama untuk menghitung feature_group_count untuk banyak konvolusi yang 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 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 menjadi pembagi 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 ukuran fitur output.

Bentuk output memiliki dimensi berikut, dalam urutan berikut:

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

Gambar di atas menunjukkan cara kerja kolom batch_group_count. Secara efektif, kita membagi setiap batch hh 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 semua dimensi lainnya (fitur dan spasial) tetap sama.

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

Untuk mendeskripsikan fungsi konvolusi, pertimbangkan konvolusi 2d, dan pilih beberapa koordinat batch, z, y, x tetap dalam output. Selanjutnya, (y,x) adalah posisi sudut jendela dalam area dasar (mis. sudut kiri atas, bergantung pada cara Anda menafsirkan dimensi spasial). Kita sekarang memiliki jendela 2d, yang diambil dari area dasar, dengan setiap titik 2d dikaitkan dengan vektor 1d, sehingga kita mendapatkan kotak 3d. Dari kernel konvolusional, karena kita memperbaiki koordinat output z, kita juga memiliki kotak 3d. Kedua kotak ini memiliki dimensi yang sama, jadi kita bisa menjumlahkan hasil perkalian elemen di antara kedua kotak (serupa dengan perkalian titik). Itulah nilai output.

Perlu diketahui bahwa jika output-z adalah mis., 5, maka setiap posisi jendela menghasilkan 5 nilai dalam output ke dimensi z output. Nilai ini berbeda dalam bagian kernel konvolusional yang digunakan - ada kotak nilai 3d terpisah yang digunakan untuk setiap koordinat output-z. Jadi Anda bisa menganggapnya sebagai 5 konvolusi terpisah dengan filter berbeda untuk setiap konvolusi.

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++, ia menjalankan operasi konversi berdasarkan elemen dari bentuk data ke bentuk target. Dimensi harus cocok, dan konversinya berbasis elemen; mis., elemen s32 menjadi elemen f32 melalui rutinitas konversi s32-ke-f32.

ConvertElementType(operand, new_element_type)

Arguments	Jenis	Semantik
operand	XlaOp	array tipe T dengan redup D
new_element_type	PrimitiveType	tipe 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-ke-float yang menormalisasi seperti bulat-ke-terdekat-genap.

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)

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

Tanda tangan fungsi sama, terlepas dari aritas 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 idempoten.

Titik

Lihat juga XlaBuilder::Dot.

Dot(lhs, rhs)

Arguments	Jenis	Semantik
lhs	XlaOp	array jenis T
rhs	XlaOp	array jenis T

Semantik persis operasi ini bergantung pada peringkat operand:

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

Operasi tersebut menjalankan jumlah produk pada dimensi kedua lhs (atau yang pertama jika memiliki peringkat 1) dan dimensi pertama rhs. Ini adalah dimensi "terkontrak". Dimensi terkontrak lhs dan rhs harus memiliki ukuran yang sama. Dalam praktiknya, AI generatif 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)

Arguments	Jenis	Semantik
lhs	XlaOp	array jenis T
rhs	XlaOp	array jenis T
dimension_numbers	DotDimensionNumbers	nomor dimensi batch dan kontrak

Mirip dengan Dot, 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	rhs nomor dimensi batch

DotGeneral melakukan jumlah produk di atas dimensi terkontrak 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 yang dikaitkan dari lhs dan rhs harus memiliki ukuran dimensi yang sama.

Contoh dengan nomor dimensi tumpukan (matriks ukuran tumpukan 2, matriks 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

Dengan begitu, nomor 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 slice di setiap dimensi diteruskan dalam size_indices, yang menentukan titik akhir interval slice eksklusif di setiap dimensi: [start, start + size). Bentuk start_indices harus memiliki peringkat == 1, dengan ukuran dimensi sama dengan peringkat operand.

DynamicSlice(operand, start_indices, size_indices)

Arguments	Jenis	Semantik
operand	XlaOp	Array dimensi N jenis T
start_indices	urutan dari XlaOp	Daftar N bilangan bulat skalar yang berisi indeks awal irisan untuk setiap dimensi. Nilai harus lebih besar atau sama dengan nol.
size_indices	ArraySlice<int64>	Daftar bilangan bulat N yang berisi ukuran irisan untuk setiap dimensi. Setiap nilai harus benar-benar lebih besar dari nol, dan ukuran awal + 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 di [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 akan selalu terikat 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 irisan update yang ditimpa pada start_indices. Bentuk update menentukan bentuk sub-array hasil yang diperbarui. Bentuk start_indices harus berperingkat == 1, dengan ukuran dimensi sama dengan peringkat operand.

DynamicUpdateSlice(operand, update, start_indices)

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

Indeks slice yang efektif dihitung dengan menerapkan transformasi berikut untuk setiap indeks i di [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 terikat 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 aritmatika biner {i>element<i}-{i>wise<i}

Lihat juga XlaBuilder::Add.

Set operasi aritmatika biner {i>element<i}-{i>wise<i} didukung.

Op(lhs, rhs)

Jika Op adalah salah satu dari Add (penambahan), Sub (pengurangan), Mul (perkalian), Div (pembagian), Rem (sisa), Max (maksimum), Min (minimum), LogicalAnd (AND logis), atau LogicalOr (logika OR).

Arguments	Jenis	Semantik
lhs	XlaOp	Operand sisi kiri: array jenis T
rhs	XlaOp	operand sisi kanan: array tipe T

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

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

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

Terdapat varian alternatif dengan dukungan penyiaran dengan tingkat yang berbeda untuk operasi ini:

Op(lhs, rhs, broadcast_dimensions)

Dengan Op sama dengan yang di atas. Varian operasi ini harus digunakan untuk operasi aritmetika 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 dengan peringkat lebih rendah ke peringkat operand dengan peringkat lebih tinggi. broadcast_dimensions memetakan dimensi bentuk dengan peringkat lebih rendah ke dimensi bentuk dengan peringkat lebih tinggi. Dimensi yang tidak dipetakan dari bentuk yang diperluas diisi dengan dimensi ukuran satu. Penyiaran dimensi merosot kemudian menyiarkan bentuk di sepanjang dimensi yang merosot ini untuk menyamakan bentuk kedua operand. Semantik dijelaskan secara mendetail di halaman penyiaran.

Operasi perbandingan {i>element<i}-{i>wise<i}

Lihat juga XlaBuilder::Eq.

Set operasi perbandingan biner standar berbasis elemen didukung. Perlu diketahui bahwa semantik perbandingan floating point IEEE 754 standar berlaku saat membandingkan jenis floating point.

Op(lhs, rhs)

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

Arguments	Jenis	Semantik
lhs	XlaOp	Operand sisi kiri: array jenis T
rhs	XlaOp	operand sisi kanan: array tipe T

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

Terdapat varian alternatif dengan dukungan penyiaran dengan tingkat yang berbeda untuk operasi ini:

Op(lhs, rhs, broadcast_dimensions)

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

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

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

XlaBuilder mendukung fungsi unary yang mengelola elemen ini:

Abs(operand) Akstratif berbasis elemen x -> |x|.

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

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

Exp(operand) x -> e^x eksponensial alami berbasis elemen.

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

Imag(operand) Bagian imajiner berbasis elemen dari bentuk kompleks (atau nyata). x -> imag(x). Jika operand adalah jenis floating point, menampilkan 0.

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

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

LogicalNot(operand) Logika berbasis elemen, bukan x -> !(x).

Logistic(operand) Komputasi fungsi logistik berbasis elemen x -> logistic(x).

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

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

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

Rsqrt(operand) Kebalikan elemen dari operasi root kuadrat x -> 1.0 / sqrt(x).

Sign(operand) Operasi tanda element-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.

Sqrt(operand) Operasi root kuadrat menurut elemen x -> sqrt(x).

Cbrt(operand) Operasi root kubik berbasis elemen x -> cbrt(x).

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

Round(operand) Pembulatan berdasarkan elemen, mengikat menjauh dari nol.

RoundNearestEven(operand) Pembulatan berdasarkan elemen, mengikat ke bilangan genap terdekat.

Arguments	Jenis	Semantik
operand	XlaOp	Operand ke fungsi

Fungsi ini diterapkan ke setiap elemen dalam array operand, sehingga menghasilkan array dengan bentuk yang sama. operand dapat berupa skalar (peringkat 0).

Fft

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

Lihat juga XlaBuilder::Fft.

Arguments	Jenis	Semantik
operand	XlaOp	Array yang kita ubah Fourier.
fft_type	FftType	Lihat tabel di bawah.
fft_length	ArraySlice<int64>	Panjang domain waktu sumbu yang diubah. Hal ini diperlukan terutama agar IRFFT 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 yang kompleks ke kompleks. Bentuk tidak berubah.
IFFT	FFT kompleks ke kompleks terbalik. Bentuk tidak berubah.
RFFT	Meneruskan FFT nyata ke kompleks. Bentuk sumbu terdalam dikurangi menjadi fft_length[-1] // 2 + 1 jika fft_length[-1] adalah nilai selain nol, yang menghilangkan bagian konjugasi terbalik dari sinyal yang ditransformasi di luar frekuensi Nyquist.
IRFFT	FFT terbalik real-ke-kompleks (yaitu mengambil kompleks, mengembalikan nyata). Bentuk sumbu terdalam diperluas menjadi fft_length[-1] jika fft_length[-1] adalah nilai bukan nol, yang menyimpulkan bagian sinyal yang diubah di luar frekuensi Nyquist dari konjugasi terbalik entri 1 ke fft_length[-1] // 2 + 1.

FFT Multidimensi

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

Detail implementasi

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

Kumpulkan

Operasi pengumpulan XLA menggabungkan beberapa irisan (setiap irisan pada offset runtime yang berpotensi berbeda) dari sebuah 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)

Arguments	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 di-offset ke dalam array yang diiris dari operand.
slice_sizes	ArraySlice<int64>	slice_sizes[i] adalah batas untuk irisan pada dimensi i.
collapsed_slice_dims	ArraySlice<int64>	Kumpulan dimensi di setiap irisan yang diciutkan. Dimensi ini harus memiliki ukuran 1.
start_index_map	ArraySlice<int64>	Peta yang menjelaskan cara memetakan indeks dalam start_indices ke indeks hukum ke dalam operand.
indices_are_sorted	bool	Apakah indeks dijamin akan diurutkan oleh pemanggil.

Untuk memudahkan, kami melabeli dimensi dalam array output, bukan di offset_dims sebagai batch_dims.

Output-nya adalah array dengan 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, secara implisit kami mempertimbangkan start_indices untuk memiliki dimensi 1 di akhir (yaitu jika start_indices memiliki bentuk [6,7] dan index_vector_dim adalah 2, maka secara implisit kami mempertimbangkan bentuk start_indices sebagai [6,7,1]).

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

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

2. Jika i ada dalam offset_dims (yaitu sama dengan offset_dims[k] untuk beberapa k), kita memilih batas yang sesuai dari slice_sizes setelah memperhitungkan 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. Misalkan G = { Out[k] untuk k di batch_dims }. Gunakan G untuk memotong vektor S sedemikian rupa sehingga S[i] = start_indices[Gabungkan(G, i)] tempat 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 operand menggunakan S dengan menyebarkan 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 dalam Out sesuai dengan kumpulan collapsed_slice_dims. 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. Jadi, jika, misalnya, 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 disetel ke benar (true), XLA dapat mengasumsikan bahwa start_indices diurutkan (dalam urutan start_index_map menaik) oleh pengguna. Jika tidak, semantik akan ditetapkan ke implementasi.

Deskripsi dan Contoh Informal

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

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

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

• Kita secara dinamis membagi sebuah potongan dengan ukuran slice_sizes menggunakan indeks awal penuh.

• Kita membentuk ulang potongan 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 irisan ini guna mendapatkan elemen input, E, yang sesuai dengan indeks output Out.

index_vector_dim ditetapkan ke start_indices.rank - 1 di 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 bagaimana semua hal di atas cocok satu sama lain, mari kita lihat contoh yang mengumpulkan 5 irisan bentuk [8,6] dari array [16,11]. Posisi irisan ke dalam array [16,11] dapat direpresentasikan sebagai vektor indeks berbentuk 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], sebuah indeks dalam bentuk output, dan memetakannya ke elemen dalam array input dengan cara berikut:

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

slice_sizes adalah [8,6], yang menentukan rentang O₀ dan O₁, lalu nilai ini menentukan batas slice.

Operasi pengumpulan ini bertindak sebagai irisan dinamis batch dengan G sebagai dimensi batch.

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

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

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

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

2. Jumlah dimensi offset output yang secara eksplisit ada dalam bentuk output mungkin lebih kecil daripada level input. Dimensi yang "tidak ada" ini, yang dicantumkan secara eksplisit sebagai collapsed_slice_dims, harus memiliki ukuran irisan 1. Karena memiliki ukuran irisan 1, satu-satunya indeks yang valid untuknya adalah 0 dan menghapusnya tidak 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 harus diperluas agar memiliki peringkat yang sama dengan input.

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

G0 dan G1 digunakan untuk memisahkan indeks awal dari array indeks kumpulkan 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 "Gather Index Mapping" (start_index_map dalam deskripsi formal) dan "Pemetaan Offset" (remapped_offset_dims dalam deskripsi formal) masing-masing menjadi [X,0] dan [0,O0], ditambahkan hingga [X,O0]. Dengan kata lain, indeks output G0, dan O0000OGGG11GatherIndicestf.gather_nd

slice_sizes untuk kasus ini adalah [1,11]. Secara intuitif, hal ini berarti bahwa setiap indeks X dalam array indeks pengumpulan mengambil seluruh baris dan hasilnya adalah gabungan dari semua baris tersebut.

GetDimensionSize

Lihat juga XlaBuilder::GetDimensionSize.

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

GetDimensionSize(operand, dimension)

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

SetDimensionSize

Lihat juga XlaBuilder::SetDimensionSize.

Menetapkan ukuran dinamis dimensi yang ditentukan XlaOp. Operand harus berbentuk array.

SetDimensionSize(operand, size, dimension)

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

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

Nilai dengan padding 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 dalam tuple dengan nilai konstanta waktu kompilasi.

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

Hal ini serupa 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.

Dalam Feed

Lihat juga XlaBuilder::Infeed.

Infeed(shape)

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

Membaca satu item data dari antarmuka streaming Infeed implisit perangkat, menafsirkan data sebagai bentuk tertentu 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 dalam kode di bawah ini memiliki urutan total karena ada dependensi antara loop when.

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 pada dasarnya adalah tanpa pengoperasian dan berlanjut tanpa membaca data apa pun dari Infeed perangkat.

Iota

Lihat juga XlaBuilder::Iota.

Iota(shape, iota_dimension)

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

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

Misalnya, Iota(s32[4, 8], 0) akan 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)

Arguments	Jenis	Semantik
operands	urutan dari 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 tertentu, yang menghasilkan array dengan dimensi yang sama, dengan setiap elemen adalah hasil dari fungsi yang dipetakan yang diterapkan pada elemen terkait dalam array input.

Fungsi yang dipetakan adalah komputasi arbitrer dengan batasan bahwa fungsi tersebut memiliki N input jenis skalar T 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 (multidimensi) dalam array input untuk menghasilkan array output.

OptimizationBarrier

Memblokir penerusan pengoptimalan agar tidak memindahkan komputasi melalui batasan.

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

Bantalan

Lihat juga XlaBuilder::Pad.

Pad(operand, padding_value, padding_config)

Arguments	Jenis	Semantik
operand	XlaOp	array jenis T
padding_value	XlaOp	skalar 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 diberikan dengan padding di sekitar array serta di antara elemen array dengan padding_value yang diberikan. 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 kelas bawah (di samping indeks 0) dan kelas atas (di samping indeks tertinggi) dari setiap dimensi. Jumlah padding tepi bisa 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; ukuran ini mungkin tidak negatif. Padding interior terjadi secara logis sebelum padding tepi, sehingga dalam kasus padding tepi negatif, elemen akan dihapus dari operand dengan padding interior.

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

Diterima

Lihat juga XlaBuilder::Recv.

Recv(shape, channel_handle)

Arguments	Jenis	Semantik
shape	Shape	bentuk data untuk menerima
channel_handle	ChannelHandle	ID unik untuk setiap pasangan kirim/recv

Menerima data bentuk tertentu dari instruksi Send dalam komputasi lain yang memiliki handle saluran yang sama. Menampilkan XlaOp untuk data yang diterima.

API klien dari operasi Recv mewakili komunikasi sinkron. Namun, petunjuk ini diurai secara internal 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 instruksi Send dengan channel_id yang sama. Menampilkan konteks untuk resource yang dialokasikan, yang digunakan oleh petunjuk RecvDone berikut untuk menunggu penyelesaian transfer data. Konteksnya adalah tuple dari {accept buffer (shape), request ID (U32)} dan hanya dapat digunakan oleh petunjuk RecvDone.

RecvDone(HloInstruction context)

Dengan mempertimbangkan konteks yang dibuat oleh instruksi Recv, tunggu hingga transfer data selesai dan menampilkan data yang diterima.

Mengurangi

Lihat juga XlaBuilder::Reduce.

Menerapkan fungsi reduksi ke satu atau beberapa array secara paralel.

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

Arguments	Jenis	Semantik
operands	Urutan N XlaOp	Array N dari jenis T_0, ..., T_{N-1}.
init_values	Urutan N XlaOp	Skalar N 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.

Dengan keterangan:

• N harus lebih besar atau sama dengan 1.
• Komputasinya harus bersifat asosiatif "kira-kira" (lihat di bawah).
• Semua array input harus memiliki dimensi yang sama.
• Semua nilai awal harus membentuk identitas di bawah computation.
• Jika N = 1, Collate(T) adalah T.
• Jika N > 1, Collate(T_0, ..., T_{N-1}) adalah tuple dari elemen N 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 dari operasi tersebut adalah Collate(Q_0, ..., Q_N), dengan Q_i adalah array jenis T_i, yang dimensinya dijelaskan di bawah ini.

Backend yang berbeda diizinkan untuk mengaitkan kembali 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 akan cukup dekat untuk bersifat asosiatif untuk sebagian besar penggunaan praktis.

Contoh

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

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

tetapi ada juga banyak kemungkinan lainnya, 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 diimplementasikan, 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). Bentuknya memiliki peringkat 2, dimensi 0 untuk ukuran 2, dan dimensi 1 untuk ukuran 3:

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

Perhatikan bahwa kedua hasil pengurangan adalah array 1D. Diagram menunjukkan satu kolom sebagai kolom dan satu lagi sebagai baris hanya untuk kenyamanan visual.

Untuk contoh yang lebih kompleks, berikut adalah array 3D. Peringkatnya adalah 3, dimensi 0 dari ukuran 4, dimensi 1 dari ukuran 2, dan dimensi 2 dari ukuran 3. Untuk mempermudah, nilai 1 hingga 6 direplikasi ke seluruh dimensi 0.

Sama seperti contoh 2D, kita dapat mengurangi satu dimensi saja. Misalnya, jika kita mengurangi dimensi 0, kita mendapatkan array peringkat 2 dengan semua nilai di dimensi 0 dilipat ke dalam skalar:

|  4   8  12 |
| 16  20  24 |

Jika kita mengurangi dimensi 2, kita juga mendapatkan array peringkat 2 dengan semua nilai di dimensi 2 dilipat ke dalam 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 akan diberi angka baru (karena peringkat berubah).

Kita juga dapat mengurangi banyak dimensi. Menambahkan dimensi pengurangan 0 dan 1 menghasilkan array 1D [20, 28, 36].

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

Pengurangan Variadik

Saat N > 1, kurangi aplikasi fungsi sedikit lebih kompleks, karena diterapkan secara bersamaan ke semua input. Operand diberikan 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, perhatikan fungsi reduksi berikut, yang dapat digunakan untuk menghitung nilai maksimum dan argmax dari 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 pengurangan f_(N-1) di satu-satunya dimensi input setara dengan penerapan 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 maksimal dan indeks yang cocok.

ReducePrecision

Lihat juga XlaBuilder::ReducePrecision.

Memodelkan 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 arbitrer, meskipun semua ukuran bit mungkin tidak didukung pada semua implementasi hardware.

ReducePrecision(operand, mantissa_bits, exponent_bits)

Arguments	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 diwakili oleh jumlah bit mantissa yang ditentukan (menggunakan semantik "sama ke genap"), dan nilai apa pun yang melebihi rentang yang ditentukan oleh jumlah bit eksponen akan dibatasi ke tak terbatas positif atau negatif. Nilai NaN dipertahankan, meskipun dapat dikonversi menjadi nilai NaN kanonis.

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

ReduceScatter

Lihat juga XlaBuilder::ReduceScatter.

Pereduksi adalah operasi kolektif yang secara efektif melakukan AllReduce, lalu menyebarkan hasilnya 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)

Arguments	Jenis	Semantik
operand	XlaOp	Array atau tuple array yang tidak kosong untuk dikurangi di seluruh replika.
computation	XlaComputation	Komputasi pengurangan
scatter_dimension	int64	Dimensi yang akan disebarkan.
shard_count	int64	Jumlah blok yang akan dipisahkan scatter_dimension
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, pengurangan sebar 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 semua pengurangan. replica_groups harus kosong (dalam hal ini semua replika dimiliki oleh satu grup), atau berisi jumlah elemen yang sama dengan jumlah replika. Jika ada lebih dari satu grup replika, semua grup replika tersebut 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 memerlukan ini 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 saling berkomunikasi.

Bentuk output adalah bentuk input dengan scatter_dimension yang dibuat shard_count kali lebih kecil. Misalnya, jika ada dua replika dan operand memiliki nilai [1.0, 2.25] dan [3.0, 5.25] masing-masing pada kedua replika, nilai output dari op 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 reduksi ke semua elemen di setiap jendela dari urutan array multidimensi N, yang menghasilkan satu atau tuple N array multidimensi 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 diteruskan init_values di sisi kiri.

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

Arguments	Jenis	Semantik
operands	N XlaOps	Urutan N array multi-dimensi dari jenis T_0,..., T_{N-1}, masing-masing mewakili area dasar tempat jendela ditempatkan.
init_values	N XlaOps	Nilai awal N untuk pengurangan, satu untuk setiap operand N. 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 agar memiliki bentuk output yang sama dengan input jika langkah-nya adalah 1, atau Padding::kValid, yang tidak menggunakan padding dan "menghentikan" jendela setelah tidak lagi sesuai)

Dengan keterangan:

• N harus lebih besar 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 dari elemen N 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 berukuran [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 di sebelahnya. Untuk menentukan bahwa tidak ada jendela yang tumpang-tindih dengan satu sama lain, window_stride_dimensions harus sama dengan window_dimensions. Gambar di bawah ini mengilustrasikan penggunaan dua nilai langkah yang berbeda. Padding diterapkan pada setiap dimensi input dan penghitungannya sama seperti meskipun input masuk dengan dimensi yang dimilikinya setelah padding.

Untuk contoh padding yang tidak umum, 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 nilai minimum lebih dari dua jendela valid: [10000, 1000, 100] dan [100, 10, 1], sehingga menghasilkan output [100, 1]. Padding kSame terlebih dahulu menempatkan array sehingga bentuk setelah jendela kurangi akan sama dengan input untuk langkah satu dengan menambahkan elemen awal di kedua sisi, mendapatkan [MAX_VALUE, 10000, 1000, 100, 10, 1, MAX_VALUE]. Menjalankan pengurangan jendela di atas array dengan padding beroperasi di 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 tidak deterministik. Oleh karena itu, fungsi pengurangan seharusnya tidak terlalu sensitif terhadap pengaitan ulang. Lihat diskusi tentang asosiatif dalam konteks Reduce untuk detail selengkapnya.

ReplicaId

Lihat juga XlaBuilder::ReplicaId.

Menampilkan ID unik (skalar U32) dari replika.

ReplicaId()

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

Membentuk ulang

Lihat juga XlaBuilder::Reshape dan operasi Collapse.

Membentuk ulang dimensi array menjadi konfigurasi baru.

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

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

Secara konseptual, membentuk ulang mula-mula akan meratakan array menjadi vektor nilai data satu dimensi, lalu menyaring vektor ini menjadi bentuk baru. Argumen input adalah array arbitrer dari jenis T, vektor konstanta waktu kompilasi dari indeks dimensi, dan vektor konstanta waktu kompilasi ukuran dimensi 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 dalam dimensions adalah dari dimensi dengan variasi paling lambat (paling besar) hingga dimensi bervariasi tercepat (paling kecil) di sarang loop yang menciutkan 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. Produk dari dimensi new_size harus sama dengan produk dari ukuran dimensi operand. Saat menyaring array yang diciutkan menjadi array multidimensi yang ditentukan oleh new_sizes, dimensi dalam new_sizes akan diurutkan dari variasi paling lambat (paling utama) dan ke bervariasi tercepat (paling kecil).

Misalnya, biarkan v menjadi array dari 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, pembentukan ulang dapat mengubah array elemen tunggal menjadi skalar dan sebaliknya. Misalnya,

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

Pendapatan (terbalik)

Lihat juga XlaBuilder::Rev.

Rev(operand, dimensions)

Arguments	Jenis	Semantik
operand	XlaOp	array jenis T
dimensions	ArraySlice<int64>	untuk membalikkan

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

Salah satu kegunaan operasi Rev adalah untuk 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 distribusi normal \(N(\mu, \sigma)\) . Parameter \(\mu\) dan \(\sigma\), serta bentuk output harus memiliki jenis elemen floating point. Parameter selanjutnya harus dinilai skalar.

RngNormal(mu, sigma, shape)

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

RngUniform

Lihat juga XlaBuilder::RngUniform.

Membuat output dari bentuk tertentu dengan angka acak yang dihasilkan dengan mengikuti distribusi seragam selama interval \([a,b)\). Parameter dan jenis 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 diberi nilai skalar. Jika \(b <= a\) hasilnya ditentukan oleh implementasi.

RngUniform(a, b, shape)

Arguments	Jenis	Semantik
a	XlaOp	Skalar tipe T yang menentukan batas interval yang lebih rendah
b	XlaOp	Skalar jenis T yang menentukan batas atas interval
shape	Shape	Bentuk output dari jenis T

RngBitGenerator

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

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

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

RngBitGenerator(algorithm, key, shape)

Arguments	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: Algoritma 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 bagian (pada indeks yang ditentukan oleh scatter_indices) yang diperbarui dengan urutan nilai di 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)

Arguments	Jenis	Semantik
operands	Urutan N XlaOp	Array N dari jenis T_0, ..., T_N yang akan disebar.
scatter_indices	XlaOp	Array yang berisi indeks awal irisan 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 pembaruan selama sebar. Komputasi ini harus berjenis T_0, ..., T_N, T_0, ..., T_N -> Collate(T_0, ..., T_N).
index_vector_dim	int64	Dimensi di 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 dimasukkan ke dalam bentuk updates.
scatter_dims_to_operand_dims	ArraySlice<int64>	Dimensi dipetakan dari indeks sebar ke ruang indeks operand. Array ini ditafsirkan sebagai memetakan i ke scatter_dims_to_operand_dims[i] . Harus one-to-one dan total.
indices_are_sorted	bool	Apakah indeks dijamin akan diurutkan oleh pemanggil.
unique_indices	bool	Apakah indeks dijamin unik oleh pemanggil.

Dengan keterangan:

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

Jika index_vector_dim sama dengan scatter_indices.rank, secara implisit kami mempertimbangkan scatter_indices untuk 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 dalam 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 memperhitungkan 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 dalam 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, 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 nomor dimensi berulang, dan berada dalam rentang [0, updates.rank).

• inserted_window_dims harus dalam urutan menaik, tidak memiliki nomor dimensi 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 berada dalam rentang [0, operand.rank).

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

1. Misalkan G = { U[k] untuk k dalam update_scatter_dims }. Gunakan G untuk mencari vektor indeks S dalam array scatter_indices sehingga S[i] = scatter_indices[Gabungkan(G, i)] tempat Gabungkan(A, b) menyisipkan b pada posisi index_vector_dim ke 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 jika tidak.
3. Buat indeks Win ke setiap array operands dengan menyebarkan indeks pada update_window_dims di U sesuai dengan inserted_window_dims. Secara lebih formal:
   1. Win[window_dims_to_operand_dims(k)] = U[k] jika k berada 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 jika tidak.
4. I adalah Win + Sin dengan + adalah penambahan berdasarkan elemen.

Singkatnya, operasi pencar dapat ditentukan sebagai berikut.

• Lakukan inisialisasi output dengan operands, yaitu untuk semua indeks J, untuk semua indeks O dalam array operands[J]:
  output[J][O] = operands[J][O]
• Untuk setiap indeks U dalam array updates[J] dan indeks terkait 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 pembaruan yang diterapkan tidaklah deterministik. Jadi, jika beberapa indeks dalam updates merujuk ke indeks yang sama di operands, nilai yang sesuai di output akan bersifat non-deterministik.

Perhatikan 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 khususnya untuk kasus ketika update_computation tidak komutatif.

Jika indices_are_sorted disetel ke benar (true), XLA dapat mengasumsikan bahwa start_indices diurutkan (dalam urutan start_index_map menaik) oleh pengguna. Jika tidak, semantik akan ditetapkan ke implementasi.

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

Secara informal, operasi sebar dapat dilihat sebagai kebalikan dari operasi pengumpulan, yaitu operasi sebar mengupdate elemen dalam input yang diekstrak oleh operasi pengumpulan yang sesuai.

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

Pilih

Lihat juga XlaBuilder::Select.

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

Select(pred, on_true, on_false)

Arguments	Jenis	Semantik
pred	XlaOp	array jenis PRED
on_true	XlaOp	array jenis T
on_false	XlaOp	array jenis T

Array on_true dan on_false harus memiliki bentuk yang sama. Ini juga merupakan bentuk dari {i>output<i}. 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 berupa skalar 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 skalar pred:

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

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!) maka pred harus berupa skalar berjenis PRED.

SelectAndScatter

Lihat juga XlaBuilder::SelectAndScatter.

Operasi ini dapat dianggap sebagai operasi komposit yang terlebih dahulu menghitung ReduceWindow pada array operand untuk memilih elemen dari setiap jendela, lalu menyebarkan array source ke indeks elemen yang dipilih untuk membuat array output dengan bentuk yang sama dengan array operand. Fungsi select biner digunakan untuk memilih elemen dari setiap jendela dengan menerapkannya di setiap jendela, dan fungsi ini dipanggil dengan properti bahwa vektor indeks parameter pertama secara leksikografis lebih kecil daripada vektor indeks parameter kedua. Fungsi select menampilkan true jika parameter pertama dipilih dan menampilkan false jika parameter kedua dipilih, dan fungsi harus memiliki 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 dilintasi untuk jendela tertentu.

Fungsi scatter diterapkan di setiap indeks yang dipilih dalam array output. Dibutuhkan dua parameter skalar:

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

Metode ini menggabungkan kedua 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 menyebarkan mundur nilai gradien untuk lapisan penggabungan dalam jaringan neural.

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

Arguments	Jenis	Semantik
operand	XlaOp	array tipe T di mana 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 jendela (Padding::kSame atau Padding::kValid)
source	XlaOp	array tipe T dengan nilai yang akan disebar
init_value	XlaOp	nilai skalar tipe T untuk nilai awal array output
scatter	XlaComputation	komputasi biner jenis T, T -> T, untuk menerapkan setiap elemen sumber sebar dengan elemen tujuannya

Gambar di bawah menunjukkan contoh penggunaan SelectAndScatter, dengan fungsi select yang menghitung nilai maksimal di antara parameternya. Perlu diketahui 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 scatter penambahan biner menghasilkan elemen output nilai 8 (2 + 6).

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

Kirim

Lihat juga XlaBuilder::Send.

Send(operand, channel_handle)

Arguments	Jenis	Semantik
operand	XlaOp	data yang akan dikirim (array jenis T)
channel_handle	ChannelHandle	ID unik untuk setiap pasangan kirim/recv

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 diurai secara internal menjadi 2 petunjuk HLO (Send dan SendDone) untuk memungkinkan 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 petunjuk SendDone berikut untuk menunggu penyelesaian transfer data. Konteksnya adalah tuple dari {operand (shape), ID permintaan (U32)} dan hanya dapat digunakan oleh instruksi SendDone.

SendDone(HloInstruction context)

Dengan mempertimbangkan konteks yang dibuat oleh instruksi Send, tunggu hingga transfer data selesai. Instruksi tidak menampilkan data apa pun.

Penjadwalan petunjuk channel

Urutan eksekusi keempat petunjuk untuk setiap saluran (Recv, RecvDone, Send, SendDone) adalah sebagai berikut.

• 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 ini menyebabkan deadlock.

Slice

Lihat juga XlaBuilder::Slice.

Mengiris 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 untuk operasi slice.

Slice(operand, start_indices, limit_indices, strides)

Arguments	Jenis	Semantik
operand	XlaOp	Array dimensi N jenis T
start_indices	ArraySlice<int64>	Daftar bilangan bulat N yang berisi indeks awal irisan 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 untuk setiap dimensi. Setiap nilai harus lebih besar 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 langkah input dari irisan. 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)

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

Jika hanya satu operand yang disediakan:

• Jika operand adalah tensor peringkat-1 (array), hasilnya adalah array yang diurutkan. Jika Anda ingin mengurutkan array ke dalam urutan menaik, pembanding harus melakukan perbandingan kurang dari. Secara formal, setelah diurutkan, array tersebut berlaku untuk semua posisi indeks i, j dengan i < j yang berupa 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 diurutkan di sepanjang dimensi yang diberikan. 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 berlaku seperti pada kasus peringkat 1.

Jika operand n > 1 disediakan:

• Semua operand n harus menjadi 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 setiap operand pada posisi indeks i dan j perlu ditukar, pembanding akan 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. Dengan demikian, pembanding akan membandingkan parameter 2 * k dan 2 * k + 1 satu sama lain dan mungkin menggunakan pasangan parameter lain sebagai pemutus ikatan.

• Hasilnya adalah tuple yang terdiri dari operand dalam urutan yang diurutkan (sepanjang dimensi yang disediakan, seperti di atas). Operand i-th dari tuple sesuai dengan operand i-th dari 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 dari pengurutan ini adalah tuple ([1, 3], [50, 42], [1.1, -3.0]).

Jika is_stable disetel ke benar (true), pengurutan akan dijamin stabil. Artinya, 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 disetel ke salah (false).

Transpose

Lihat juga operasi tf.reshape.

Transpose(operand)

Arguments	Jenis	Semantik
operand	XlaOp	Operand yang akan di-transposisi.
permutation	ArraySlice<int64>	Cara mengaktifkan dimensi.

Membisukan 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(permutasi, operand.shape.dimensions)).

TriangularSolve

Lihat juga XlaBuilder::TriangularSolve.

Menyelesaikan sistem persamaan linear dengan matriks koefisien segitiga bawah atau atas dengan substitusi maju atau mundur. Melakukan siaran di sepanjang dimensi utama, rutinitas ini menyelesaikan salah satu sistem matriks op(a) * x = b, atau x * op(a) = b, untuk variabel x, dengan mempertimbangkan 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)

Arguments	Jenis	Semantik
a	XlaOp	array peringkat > 2 dari jenis kompleks atau floating point dengan bentuk [..., M, M].
b	XlaOp	array peringkat > 2 dari jenis yang sama dengan bentuk [..., M, K] jika left_side benar, jika tidak, [..., K, M].
left_side	bool	menunjukkan apakah akan menyelesaikan sistem bentuk 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 bisa berupa apa saja.

Jika peringkat a dan b lebih besar dari 2, keduanya 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 jumlah variabel handle data, yang masing-masing memiliki bentuknya sendiri.

Hal ini serupa 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)

Arguments	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.

Eksekusi body secara berurutan hingga condition gagal. Hal ini mirip dengan loop sementara yang biasa dilakukan dalam banyak bahasa lain, kecuali untuk perbedaan dan batasan yang tercantum di bawah ini.

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

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

Salah satu kasus penggunaan utama node While adalah untuk mengimplementasikan eksekusi berulang pelatihan dalam jaringan neural. Kode semu yang disederhanakan ditampilkan di bawah ini 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};
}