Semantik operasi

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

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

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

AfterAll

Lihat juga XlaBuilder::AfterAll.

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

AfterAll(operands)

AllGather

Lihat juga XlaBuilder::AllGather.

Melakukan penyambungan di seluruh replika.

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

• replica_groups adalah daftar grup replika tempat penyambungan dilakukan (ID replika untuk replika saat ini dapat diambil menggunakan ReplicaId). Urutan replika di setiap grup menentukan urutan penempatan inputnya dalam hasil. replica_groups harus kosong (dalam hal ini, semua replika termasuk dalam satu grup, yang diurutkan dari 0 ke N - 1), atau berisi jumlah elemen yang sama dengan jumlah replika. Misalnya, replica_groups = {0, 2}, {1, 3} melakukan penggabungan antara replika 0 dan 2, serta 1 dan 3.
• shard_count adalah ukuran setiap grup replika. Kita memerlukannya jika replica_groups kosong.
• channel_id digunakan untuk komunikasi lintas modul: hanya operasi all-gather dengan channel_id yang sama yang dapat 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] di kedua replika, nilai output dari operasi ini dengan all_gather_dim adalah 0 akan menjadi [1.0, 2.5, 3.0, 5.25] di kedua replika.

AllReduce

Lihat juga XlaBuilder::AllReduce.

Melakukan komputasi kustom di seluruh replika.

AllReduce(operand, computation, replica_group_ids, channel_id)

• Jika operand adalah tuple array, all-reduce 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). replica_groups harus kosong (dalam hal ini, semua replika termasuk dalam satu grup), atau berisi jumlah elemen yang sama dengan jumlah replika. Misalnya, replica_groups = {0, 2}, {1, 3} melakukan pengurangan antara replika 0 dan 2, serta 1 dan 3.
• channel_id digunakan untuk komunikasi lintas modul: hanya operasi all-reduce dengan channel_id yang sama yang dapat 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 operasi ini dan komputasi penjumlahan akan menjadi [4.0, 7.75] di kedua replika. Jika inputnya adalah tuple, outputnya juga merupakan tuple.

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

AllToAll

Lihat juga XlaBuilder::AllToAll.

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

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

Core yang berpartisipasi dapat dikonfigurasi dengan:

• replica_groups: setiap ReplicaGroup berisi daftar ID replika yang berpartisipasi dalam komputasi (ID replika untuk replika saat ini dapat diambil menggunakan ReplicaId). AllToAll akan diterapkan dalam subgrup dalam urutan yang ditentukan. Misalnya, replica_groups = { {1,2,3}, {4,5,0} } berarti 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 penyambungan juga 4, 5, 0. Jika replica_groups kosong, semua replika termasuk dalam satu grup, dalam urutan penyambungan kemunculan replika.

Prasyarat:

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

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

Di bawah ini adalah contoh Alltoall.

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

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

BatchNormGrad

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

Menghitung gradien batch norm.

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

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

Tiga gradien ditentukan oleh formula berikut (dengan asumsi array 4 dimensi sebagai operand dan dengan indeks dimensi fitur l, ukuran batch m, dan ukuran spasial w dan h):

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

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

Jenis output adalah tuple dari tiga nama sebutan channel:

BatchNormInference

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

Mennormalisasi array di seluruh dimensi batch dan spasial.

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

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

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

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

BatchNormTraining

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

Mennormalisasi array di seluruh dimensi batch dan spasial.

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

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

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

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

• Menghitung 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$

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

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

Jenis output adalah tuple dari tiga XlaOp:

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

BitcastConvertType

Lihat juga XlaBuilder::BitcastConvertType.

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

BitcastConvertType(operand, new_element_type)

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

Jenis elemen sumber dan tujuan tidak boleh berupa tuple.

Konversi bitcast ke jenis primitif dengan lebar yang berbeda

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

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

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

Aturan tetap sama untuk skalar efektif:

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

Atau, untuk B' > B, petunjuk memerlukan dimensi logis terakhir dari bentuk input yang 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 dilakukan secara elemen.

Siaran

Lihat juga XlaBuilder::Broadcast.

Menambahkan dimensi ke array dengan menduplikasi data dalam array.

Broadcast(operand, broadcast_sizes)

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

Dimensi baru mengindeks ke salinan operand, yaitu

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

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

BroadcastInDim

Lihat juga XlaBuilder::BroadcastInDim.

Memperluas ukuran dan jumlah dimensi array dengan menduplikasi data dalam array.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

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

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

Telepon

Lihat juga XlaBuilder::Call.

Memanggil komputasi dengan argumen yang diberikan.

Call(computation, args...)

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

CompositeCall

Lihat juga XlaBuilder::CompositeCall.

Mengenkapsulasi operasi yang terdiri dari (terdiri dari) operasi StableHLO lainnya, mengambil input dan composite_attributes, serta menghasilkan hasil. Semantik op diimplementasikan oleh atribut dekomposisi. Operasi gabungan dapat diganti dengan dekomposisinya tanpa mengubah semantik program. Jika penyertaan dekomposisi tidak memberikan semantik op yang sama, sebaiknya gunakan custom_call.

Kolom versi (defaultnya 0) digunakan untuk menunjukkan kapan semantik komposit berubah.

Operasi ini diimplementasikan sebagai kCall dengan atribut is_composite=true. Kolom decomposition ditentukan oleh atribut computation. Atribut frontend menyimpan atribut yang tersisa dengan awalan composite..

Contoh operasi CompositeCall:

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

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

Cholesky

Lihat juga XlaBuilder::Cholesky.

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

Cholesky(a, lower)

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

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

Jika a memiliki lebih dari 2 dimensi, a akan diperlakukan sebagai batch matriks, dengan semua kecuali 2 dimensi minor adalah dimensi batch.

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

Pembatas

Lihat juga XlaBuilder::Clamp.

Membatasi operand dalam rentang antara nilai minimum dan maksimum.

Clamp(min, operand, max)

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

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

Contoh dengan skalar min dan max:

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

Ciutkan

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

Menciutkan dimensi array menjadi satu dimensi.

Collapse(operand, dimensions)

Collapse mengganti subset dimensi operand tertentu dengan satu dimensi. Argumen input adalah array arbitrer dari jenis T dan vektor konstanta waktu kompilasi dari indeks dimensi. Indeks dimensi harus berurutan (angka dimensi rendah ke tinggi), subset berturut-turut dari dimensi T. Dengan demikian, {0, 1, 2}, {0, 1}, atau {1, 2} adalah kumpulan dimensi yang valid, tetapi {1, 0} atau {0, 2} tidak valid. Dimensi tersebut diganti dengan satu dimensi baru, di posisi yang sama dalam urutan dimensi seperti yang diganti, dengan ukuran dimensi baru yang sama dengan produk ukuran dimensi asli. Nomor dimensi terendah di dimensions adalah dimensi yang bervariasi paling lambat (paling utama) dalam loop nest yang menciutkan dimensi ini, dan nomor dimensi tertinggi adalah yang bervariasi paling cepat (paling minor). Lihat operator tf.reshape jika diperlukan urutan penyingkatan yang lebih umum.

Misalnya, v adalah array yang berisi 24 elemen:

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

// 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 lintas data.

CollectivePermute(operand, source_target_pairs)

Perhatikan bahwa ada batasan berikut pada source_target_pair:

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

Menggabungkan

Lihat juga XlaBuilder::ConcatInDim.

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

Concatenate(operands..., dimension)

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

Contoh 1 dimensi:

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

Contoh 2 dimensi:

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

Diagram:

Kondisional

Lihat juga XlaBuilder::Conditional.

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

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

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

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

Conditional(branch_index, branch_computations, branch_operands)

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

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

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

Conv (konvolusi)

Lihat juga XlaBuilder::Conv.

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

ConvWithGeneralPadding (konvolusi)

Lihat juga XlaBuilder::ConvWithGeneralPadding.

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

Misalkan n adalah jumlah dimensi spasial. Argumen lhs adalah array dimensi (n+2) yang menjelaskan 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 ini:

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

Argumen rhs adalah array dimensi (n+2) yang menjelaskan filter/kernel/jendela konvolusi. Dimensi tersebut adalah, dalam urutan ini:

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

Argumen window_strides menentukan langkah jendela convolutional dalam dimensi spasial. Misalnya, jika langkah dalam dimensi spasial pertama adalah 3, jendela hanya dapat ditempatkan pada koordinat tempat indeks spasial pertama dapat dibagi dengan 3.

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

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

Dilatasi rhs juga disebut konvolusi atrous. Untuk detail selengkapnya, lihat tf.nn.atrous_conv2d. Dilasi lhs juga disebut konvolusi yang ditransposisi. 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 berupa pembagi dimensi fitur input dan output. Jika feature_group_count lebih besar dari 1, artinya secara konseptual dimensi fitur input dan output serta dimensi fitur output rhs dibagi secara merata menjadi banyak grup feature_group_count, dengan setiap grup terdiri dari suburutan fitur yang berurutan. Dimensi fitur input rhs harus sama dengan dimensi fitur input lhs dibagi dengan feature_group_count (sehingga sudah memiliki ukuran grup fitur input). Grup ke-i digunakan bersama untuk menghitung feature_group_count untuk banyak konvolusi terpisah. Hasil dari konvolusi ini digabungkan dalam dimensi fitur output.

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

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

Bentuk output memiliki dimensi berikut, dalam urutan ini:

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

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

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

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

Perhatikan bahwa jika output-z adalah, misalnya, 5, maka setiap posisi jendela akan menghasilkan 5 nilai dalam output ke dimensi z output. Nilai ini berbeda di bagian kernel convolutional yang digunakan - ada kotak nilai 3D terpisah yang digunakan untuk setiap koordinat output-z. Jadi, Anda dapat menganggapnya sebagai 5 konvolusi terpisah dengan filter yang 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 element-wise di C++, melakukan operasi konversi element-wise dari bentuk data ke bentuk target. Dimensi harus cocok, dan konversi adalah konversi per elemen; misalnya, elemen s32 menjadi elemen f32 melalui rutinitas konversi s32-ke-f32.

ConvertElementType(operand, new_element_type)

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

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

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

CrossReplicaSum

Melakukan AllReduce dengan komputasi penjumlahan.

CustomCall

Lihat juga XlaBuilder::CustomCall.

Panggil fungsi yang disediakan pengguna dalam komputasi.

CustomCall(target_name, args..., shape)

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

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

Misalnya, jika CustomCall digunakan sebagai berikut:

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

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

Berikut adalah contoh implementasi myfunc:

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

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

Titik

Lihat juga XlaBuilder::Dot.

Dot(lhs, rhs)

Semantik yang tepat dari operasi ini bergantung pada peringkat operand:

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

DotGeneral

Lihat juga XlaBuilder::DotGeneral.

DotGeneral(lhs, rhs, dimension_numbers)

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

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

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

Contoh dengan nomor dimensi yang berkontraksi:

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

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

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

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

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

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

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

DynamicSlice

Lihat juga XlaBuilder::DynamicSlice.

DynamicSlice mengekstrak sub-array dari array input pada start_indices dinamis. Ukuran 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 berdimensi 1, dengan ukuran dimensi sama dengan jumlah dimensi operand.

DynamicSlice(operand, start_indices, size_indices)

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

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

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

Contoh 1 dimensi:

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

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

Contoh 2 dimensi:

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

DynamicSlice(b, s, {2, 2}) produces:
{ { 7.0,  8.0},
{10.0, 11.0} }

DynamicUpdateSlice

Lihat juga XlaBuilder::DynamicUpdateSlice.

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

DynamicUpdateSlice(operand, update, start_indices)

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

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

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

Contoh 1 dimensi:

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

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

Contoh 2 dimensi:

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

let s = {1, 1}

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

Operasi aritmetika biner per elemen

Lihat juga XlaBuilder::Add.

Serangkaian operasi aritmetika biner per elemen didukung.

Op(lhs, rhs)

Dengan Op adalah salah satu dari Add (penambahan), Sub(pengurangan), Mul (perkalian), Div (pembagian), Pow (pangkat), Rem (sisa), Max (maksimum), Min (minimum), And (logika DAN), Or (logika ATAU), Xor (logika XOR), ShiftLeft (Left Shift), ShiftRightArithmetic (arithmetic Right Shift), ShiftRightLogical (logika Right Shift), Atan2 (arctangent 2 argumen), atau Complex (menggabungkan bagian nyata dan imajiner menjadi bilangan kompleks)

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

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

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

Varian alternatif dengan dukungan siaran berdimensi berbeda tersedia untuk operasi ini:

Op(lhs, rhs, broadcast_dimensions)

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

Operand broadcast_dimensions tambahan adalah bagian dari bilangan bulat yang digunakan untuk memperluas jumlah dimensi operand berdimensi lebih rendah hingga jumlah dimensi operand berdimensi lebih tinggi. broadcast_dimensions memetakan dimensi bentuk berdimensi lebih rendah ke dimensi bentuk berdimensi lebih tinggi. Dimensi yang tidak dipetakan dari bentuk yang diperluas diisi dengan dimensi berukuran satu. Penyiaran dimensi degenere kemudian menyiarkan bentuk di sepanjang dimensi degenere ini untuk menyamakan bentuk kedua operand. Semantik dijelaskan secara mendetail di halaman siaran.

Operasi perbandingan per elemen

Lihat juga XlaBuilder::Eq.

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

Op(lhs, rhs)

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

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

Varian alternatif dengan dukungan siaran berdimensi berbeda tersedia untuk operasi ini:

Op(lhs, rhs, broadcast_dimensions)

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

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

Fungsi unary per elemen

XlaBuilder mendukung fungsi unary per elemen berikut:

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

Cbrt(operand) Operasi akar kubik per elemen x -> cbrt(x).

Ceil(operand) Element-wise ceil x -> ⌈x⌉.

Clz(operand) Menghitung nol di awal menurut elemen.

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

Erf(operand) Fungsi error per elemen x -> erf(x) dengan

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

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

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

Floor(operand) Elemen per lantai x -> ⌊x⌋.

Imag(operand) Bagian imajiner per elemen dari bentuk kompleks (atau riil). 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 seperti input, dengan setiap elemen adalah true jika dan hanya jika elemen input yang sesuai bersifat terbatas.

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

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

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

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

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

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

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

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

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

Rsqrt(operand) Invers elemen per operasi akar kuadrat x -> 1.0 / sqrt(x).

Sign(operand) Operasi tanda elemen x -> sgn(x) dengan

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

menggunakan operator perbandingan jenis elemen operand.

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

Sqrt(operand) Operasi akar kuadrat per elemen x -> sqrt(x).

Tan(operand) Tangent per elemen x -> tan(x).

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

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

Fft

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

Lihat juga XlaBuilder::Fft.

FFT Multidimensi

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

Detail implementasi

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

Mengumpulkan

Operasi pengumpulan XLA menggabungkan beberapa slice (setiap slice pada offset runtime yang berpotensi berbeda) dari array input.

Semantik Umum

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

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

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

Output-nya adalah array dengan dimensi batch_dims.size + offset_dims.size.

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

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

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

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

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

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

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

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

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

   2. Sin[_] = 0 jika tidak.

3. Buat indeks Oin ke dalam operand dengan menyebarkan indeks pada dimensi offset di 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}, maka remapped_offset_dims adalah {0→1, 1→3, 2→4, 3→5}.

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

Deskripsi dan Contoh Informal

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

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

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

• Kita memotong slice secara dinamis dengan ukuran slice_sizes menggunakan indeks awal lengkap.

• Kita membentuk ulang slice dengan menciutkan dimensi collapsed_slice_dims. Karena semua dimensi slice yang diciutkan harus memiliki batas 1, pembentukan ulang ini selalu valid.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GetDimensionSize

Lihat juga XlaBuilder::GetDimensionSize.

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

GetDimensionSize(operand, dimension)

SetDimensionSize

Lihat juga XlaBuilder::SetDimensionSize.

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

SetDimensionSize(operand, size, dimension)

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

Nilai yang ditambahkan akan diabaikan oleh operasi pengurangan downstream.

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

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

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

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

GetTupleElement

Lihat juga XlaBuilder::GetTupleElement.

Mengindeks ke dalam tuple dengan nilai konstanta waktu kompilasi.

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

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

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

Lihat juga tf.tuple.

Infeed

Lihat juga XlaBuilder::Infeed.

Infeed(shape)

Membaca satu item data dari antarmuka streaming Infeed implisit perangkat, menafsirkan data sebagai bentuk yang diberikan dan tata letaknya, serta 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 memiliki urutan total karena ada dependensi antara loop while.

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

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

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

Iota

Lihat juga XlaBuilder::Iota.

Iota(shape, iota_dimension)

Membuat literal konstan di perangkat, bukan transfer host yang berpotensi besar. Membuat array yang memiliki bentuk yang ditentukan 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(...)) dengan Iota berjenis integral dan konversinya adalah ke jenis floating point.

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

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

Pengembalian dengan biaya Iota(s32[4, 8], 1)

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

Peta

Lihat juga XlaBuilder::Map.

Map(operands..., computation)

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

Fungsi yang dipetakan adalah komputasi arbitrer dengan batasan bahwa fungsi tersebut memiliki input N dari 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 semua kartu pengoptimalan agar tidak memindahkan komputasi melintasi penghalang.

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

Bantalan

Lihat juga XlaBuilder::Pad.

Pad(operand, padding_value, padding_config)

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 bagian bawah (di samping indeks 0) dan bagian atas (di samping indeks tertinggi) dari setiap dimensi. Jumlah padding tepi dapat 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; nilainya tidak boleh negatif. Padding interior terjadi secara logis sebelum padding tepi, sehingga dalam kasus padding tepi negatif, elemen akan dihapus dari operand yang dipadding interior.

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

Recv

Lihat juga XlaBuilder::Recv.

Recv(shape, channel_handle)

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

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

Recv(const Shape& shape, int64 channel_id)

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

RecvDone(HloInstruction context)

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

Reduce (Mengurangi)

Lihat juga XlaBuilder::Reduce.

Menerapkan fungsi pengurangan ke satu atau beberapa array secara paralel.

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

Dengan keterangan:

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

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

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

Contoh

Saat mengurangi di satu dimensi dalam satu array 1D dengan nilai [10, 11, 12, 13], dengan fungsi pengurangan f (ini adalah computation), nilai 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 pseudo-kode kasar tentang cara pengurangan dapat 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 number of dimensions of the result.
for r0 in range(result_shape[0]), r1 in range(result_shape[1]), ...:
  # Initialize this result element
  result[r0, r1...] <- 0

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

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

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

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

Untuk contoh yang lebih kompleks, berikut adalah array 3D. Jumlah dimensinya adalah 3, dimensi 0 berukuran 4, dimensi 1 berukuran 2, dan dimensi 2 berukuran 3. Untuk kemudahan, nilai 1 hingga 6 direplikasi di seluruh dimensi 0.

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

|  4   8  12 |
| 16  20  24 |

Jika mengurangi dimensi 2, kita juga akan mendapatkan array 2 dimensi dengan semua nilai di seluruh dimensi 2 dilipat menjadi skalar:

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

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

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

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

Variadic Reduce

Jika N > 1, penerapan fungsi pengurangan sedikit lebih rumit, karena diterapkan secara bersamaan ke semua input. Operand disediakan ke komputasi dalam urutan berikut:

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

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

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

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

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

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

ReducePrecision

Lihat juga XlaBuilder::ReducePrecision.

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

ReducePrecision(operand, mantissa_bits, exponent_bits)

Hasilnya adalah array jenis T. Nilai input dibulatkan ke nilai terdekat yang dapat direpresentasikan dengan jumlah bit mantissa yang diberikan (menggunakan semantik "ties to even"), dan nilai apa pun yang melebihi rentang yang ditentukan oleh jumlah bit eksponen akan dikencangkan ke nilai tak terbatas positif atau negatif. Nilai NaN akan dipertahankan, meskipun dapat dikonversi menjadi nilai NaN kanonis.

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

ReduceScatter

Lihat juga XlaBuilder::ReduceScatter.

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

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

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

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

ReduceWindow

Lihat juga XlaBuilder::ReduceWindow.

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

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

Dengan keterangan:

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

Kode dan gambar di bawah menunjukkan contoh penggunaan ReduceWindow. Input adalah matriks berukuran [4x6] dan window_dimensions serta window_stride_dimensions adalah [2x3].

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

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

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

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

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

ReplicaId

Lihat juga XlaBuilder::ReplicaId.

Menampilkan ID unik (skalar U32) replika.

ReplicaId()

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

Pembentukan ulang

Lihat juga XlaBuilder::Reshape dan operasi Collapse.

Mengubah bentuk dimensi array menjadi konfigurasi baru.

Reshape(operand, dimensions)

Secara konseptual, reshape pertama kali 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 dari ukuran dimensi untuk hasilnya. Vektor dimensions menentukan ukuran array output. Nilai pada indeks 0 di dimensions adalah ukuran dimensi 0, nilai pada indeks 1 adalah ukuran dimensi 1, dan seterusnya. Hasil dimensi dimensions harus sama dengan hasil ukuran dimensi operand. Saat menyaring array yang diciutkan menjadi array multidimensi yang ditentukan oleh dimensions, dimensi di dimensions diurutkan dari variasi paling lambat (paling utama) hingga variasi tercepat (paling minor).

Misalnya, v adalah array yang berisi 24 elemen:

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

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

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

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

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

Rev (mundur)

Lihat juga XlaBuilder::Rev.

Rev(operand, dimensions)

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 ditransformasi. Indeks multidimensi ditransformasikan dengan membalikkan indeks di setiap dimensi yang akan dibalik (yaitu, jika dimensi berukuran N adalah salah satu dimensi yang dibalik, indeksnya i diubah menjadi N - 1 - i).

Salah satu penggunaan operasi Rev adalah untuk membalikkan array bobot konvolusi di sepanjang dua dimensi jendela selama komputasi gradien di jaringan saraf.

RngNormal

Lihat juga XlaBuilder::RngNormal.

Membuat output 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. Selain itu, parameter harus berupa nilai skalar.

RngNormal(mu, sigma, shape)

RngUniform

Lihat juga XlaBuilder::RngUniform.

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

RngUniform(a, b, shape)

RngBitGenerator

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

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

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

RngBitGenerator(algorithm, key, shape)

Nilai yang tersedia untuk algorithm:

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

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

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

Sebar

Operasi sebar XLA menghasilkan urutan hasil yang merupakan nilai array input operands, dengan beberapa slice (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)

Dengan keterangan:

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

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

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

Argumen scatter harus mengikuti batasan berikut:

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

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

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

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

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

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

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

Singkatnya, operasi penyebaran 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 yang sesuai O dalam array operand[J], jika O adalah indeks yang valid untuk output:
  (output[0][O], ..., output[N-1][O]) =update_computation(output[0][O], ..., ,output[N-1][O],updates[0][U], ...,updates[N-1][U])

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

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

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

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

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

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

Pilih

Lihat juga XlaBuilder::Select.

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

Select(pred, on_true, on_false)

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

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

Contoh dengan pred non-skalar:

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

Contoh dengan pred skalar:

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

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

SelectAndScatter

Lihat juga XlaBuilder::SelectAndScatter.

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

Fungsi scatter diterapkan 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 sebaran dari source yang berlaku untuk indeks yang dipilih

Fungsi 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 melakukan backpropagation nilai gradien untuk lapisan penggabungan dalam jaringan saraf.

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

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

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

Kirim

Lihat juga XlaBuilder::Send.

Send(operand, channel_handle)

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

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

Send(HloInstruction operand, int64 channel_id)

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

SendDone(HloInstruction context)

Dengan konteks yang dibuat oleh petunjuk Send, menunggu transfer data selesai. Petunjuk tidak menampilkan data apa pun.

Menjadwalkan petunjuk channel

Urutan eksekusi 4 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 menyebabkan deadlock.

Perhatikan bahwa batasan pada petunjuk hanya berlaku untuk TPU saat runtime. Di GPU, send dan recv akan memblokir dan tidak mengirim data sebenarnya hingga setelah handshake antara perangkat sumber dan target.

Slice

Lihat juga XlaBuilder::Slice.

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

Slice(operand, start_indices, limit_indices, strides)

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)

Jika hanya satu operand yang diberikan:

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

• Jika operand memiliki jumlah dimensi yang lebih tinggi, operand akan diurutkan berdasarkan dimensi yang diberikan. Misalnya, untuk tensor 2 dimensi (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 dalam kasus 1 dimensi.

Jika operand n > 1 diberikan:

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

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

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

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

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

TopK

Lihat juga XlaBuilder::TopK.

TopK menemukan nilai dan indeks elemen terbesar atau terkecil k untuk dimensi terakhir tensor yang diberikan.

TopK(operand, k, largest)

Untuk tensor input 1 dimensi (array), temukan entri terbesar atau terkecil k dalam array dan hasilkan tuple dari dua array (values, indices). Dengan demikian, values[j] adalah entri terbesar/terkecil ke-j di operand, dan indeksnya adalah indices[j].

Untuk tensor input dengan lebih dari 1 dimensi, komputasi entri k teratas di sepanjang dimensi terakhir, dengan mempertahankan semua dimensi (baris) lainnya dalam output. Jadi, untuk operand bentuk [A, B, ..., P, Q] dengan Q >= k, outputnya adalah tuple (values, indices) dengan:

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

Jika dua elemen dalam baris sama, elemen indeks yang lebih rendah akan muncul terlebih dahulu.

Transpose

Lihat juga operasi tf.reshape.

Transpose(operand)

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

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

TriangularSolve

Lihat juga XlaBuilder::TriangularSolve.

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

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

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

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

Tuple

Lihat juga XlaBuilder::Tuple.

Tuple yang berisi jumlah variabel handle data, yang masing-masing memiliki bentuk sendiri.

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

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

Tuple dapat didekonstruksi (diakses) melalui operasi GetTupleElement.

Meskipun

Lihat juga XlaBuilder::While.

While(condition, body, init)

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

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

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

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

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