Semantik operasi

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

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

Pelajari lebih lanjut struktur Op di Bentuk dan tata letak dan Tata Letak Berpetak.

Perut

Lihat juga XlaBuilder::Abs.

Absolut per elemen x -> |x|.

Abs(operand)

Untuk informasi StableHLO, lihat StableHLO - abs.

Tambahkan

Lihat juga XlaBuilder::Add.

Melakukan penambahan per elemen lhs dan rhs.

Add(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran dimensi berbeda tersedia untuk Tambahkan:

Add(lhs,rhs, broadcast_dimensions)

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

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

Untuk mengetahui informasi StableHLO, lihat StableHLO - add.

AddDependency

Lihat juga HloInstruction::AddDependency.

AddDependency dapat muncul dalam dump HLO, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

AfterAll

Lihat juga XlaBuilder::AfterAll.

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

AfterAll(tokens)

Untuk informasi StableHLO, lihat StableHLO - after_all.

AllGather

Lihat juga XlaBuilder::AllGather.

Melakukan penggabungan di seluruh replika.

AllGather(operand, all_gather_dimension, shard_count, replica_groups, channel_id, layout, use_global_device_ids)

• replica_groups adalah daftar grup replika yang di antaranya penggabungan dilakukan (ID replika untuk replika saat ini dapat diambil menggunakan ReplicaId). Urutan replika di setiap grup menentukan urutan inputnya dalam hasil. replica_groups harus kosong (dalam hal ini semua replika termasuk dalam satu grup, diurutkan dari 0 hingga N - 1), atau berisi jumlah elemen yang sama dengan jumlah replika. Misalnya, replica_groups = {0, 2}, {1, 3} melakukan penggabungan antara replika 0 dan 2, serta 1 dan 3.
• shard_count adalah ukuran setiap grup replika. Kami 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.
• use_global_device_ids Menampilkan benar jika ID dalam konfigurasi ReplicaGroup merepresentasikan ID global (replica_id * partition_count + partition_id) bukan ID replika. Hal ini memungkinkan pengelompokan perangkat yang lebih fleksibel jika all-reduce ini bersifat lintas partisi dan lintas replika.

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

API AllGather secara internal diuraikan menjadi 2 instruksi HLO (AllGatherStart dan AllGatherDone).

Lihat juga HloInstruction::CreateAllGatherStart.

AllGatherStart, AllGatherDone berfungsi sebagai primitif di HLO. Operasi ini mungkin muncul dalam dump HLO, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

Untuk informasi StableHLO, lihat StableHLO - all_gather.

AllReduce

Lihat juga XlaBuilder::AllReduce.

Melakukan komputasi kustom di seluruh replika.

AllReduce(operand, computation, replica_groups, channel_id, shape_with_layout, use_global_device_ids)

• Jika operand adalah tuple array, semua pengurangan dilakukan pada setiap elemen tuple.
• replica_groups adalah daftar grup replika yang di antaranya 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.
• shape_with_layout: memaksa tata letak AllReduce ke tata letak yang diberikan. Ini digunakan untuk menjamin tata letak yang sama untuk sekelompok operasi AllReduce yang dikompilasi secara terpisah.
• use_global_device_ids Menampilkan benar jika ID dalam konfigurasi ReplicaGroup merepresentasikan ID global (replica_id * partition_count + partition_id) bukan ID replika. Hal ini memungkinkan pengelompokan perangkat yang lebih fleksibel jika all-reduce ini bersifat lintas partisi dan lintas replika.

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 kedua replika, maka nilai output dari operasi ini dan perhitungan penjumlahan akan menjadi [4.0, 7.75] pada kedua replika. Jika input adalah tuple, outputnya juga berupa tuple.

Menghitung hasil AllReduce memerlukan satu input dari setiap replika, jadi jika satu replika mengeksekusi node AllReduce lebih banyak daripada replika lain, maka replika pertama akan menunggu selamanya. Karena semua replika menjalankan program yang sama, tidak banyak cara agar hal itu terjadi, tetapi hal itu mungkin terjadi saat kondisi loop while bergantung pada data dari infeed dan data yang infeed menyebabkan loop while beriterasi lebih banyak pada satu replika daripada replika lainnya.

API AllReduce secara internal diuraikan menjadi 2 instruksi HLO (AllReduceStart dan AllReduceDone).

Lihat juga HloInstruction::CreateAllReduceStart.

AllReduceStart dan AllReduceDone berfungsi sebagai primitif di HLO. Operasi ini mungkin muncul dalam dump HLO, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

CrossReplicaSum

Lihat juga XlaBuilder::CrossReplicaSum.

Melakukan AllReduce dengan penghitungan penjumlahan.

CrossReplicaSum(operand, replica_groups)

Menampilkan jumlah nilai operand dalam setiap subgrup replika. Semua replika menyediakan satu input ke jumlah dan semua replika menerima jumlah yang dihasilkan untuk setiap subgrup.

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-blok tersebut disebarkan ke semua core, misalnya, blok ke-i dikirim ke core ke-i.
2. Fase pengumpulan. Setiap inti menggabungkan blok yang diterima di sepanjang concat_dimension.

Core yang berpartisipasi dapat dikonfigurasi oleh:

• 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 penggabungannya juga 4, 5, 0. Jika replica_groups kosong, semua replika termasuk dalam satu grup, dalam urutan penggabungan kemunculannya.

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, layout, channel_id)

Lihat xla::shapes untuk mengetahui informasi selengkapnya tentang bentuk dan tata letak..

Untuk informasi StableHLO, lihat StableHLO - all_to_all.

AllToAll - Contoh 1.

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 di atas, 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]. Keempat bagian tersebut tersebar di semua core. Kemudian, setiap core menggabungkan bagian yang diterima di sepanjang dimensi 0, dalam urutan core 0-4. Jadi, output di setiap core memiliki bentuk f32[16,4].

AllToAll - Contoh 2 - StableHLO

Dalam contoh di atas, ada 2 replika yang berpartisipasi dalam AllToAll. Pada setiap replika, operand memiliki bentuk f32[2,4]. Operand dibagi menjadi 2 bagian di sepanjang dimensi 1, sehingga setiap bagian memiliki bentuk f32[2,2]. Kedua bagian tersebut kemudian dipertukarkan di seluruh replika sesuai dengan posisinya dalam grup replika. Setiap replika mengumpulkan bagian yang sesuai dari kedua operand dan menggabungkannya di sepanjang dimensi 0. Akibatnya, output pada setiap replika memiliki bentuk f32[4,2].

RaggedAllToAll

Lihat juga XlaBuilder::RaggedAllToAll.

RaggedAllToAll melakukan operasi all-to-all kolektif, dengan input dan output berupa tensor tidak beraturan.

RaggedAllToAll(input, input_offsets, send_sizes, output, output_offsets, recv_sizes, replica_groups, channel_id)

Tensor tidak beraturan ditentukan oleh tiga set tensor:

• data: tensor data “tidak beraturan” di sepanjang dimensi terluarnya, yang di sepanjangnya setiap elemen yang diindeks memiliki ukuran yang bervariasi.
• offsets': tensor offsets mengindeks dimensi terluar tensor data, dan merepresentasikan offset awal setiap elemen tidak beraturan dari tensor data.
• sizes: tensor sizes merepresentasikan ukuran setiap elemen tidak beraturan dari tensor data, dengan ukuran yang ditentukan dalam satuan sub-elemen. Sub-elemen ditentukan sebagai akhiran bentuk tensor 'data' yang diperoleh dengan menghapus dimensi “tidak beraturan” terluar.
• Tensor offsets dan sizes harus memiliki ukuran yang sama.

Contoh tensor tidak beraturan:

data: [8,3] =
{ {a,b,c},{d,e,f},{g,h,i},{j,k,l},{m,n,o},{p,q,r},{s,t,u},{v,w,x} }

offsets: [3] = {0, 1, 4}

sizes: [3] = {1, 3, 4}

// Index 'data' at 'offsets'[0], 'sizes'[0]' // {a,b,c}

// Index 'data' at 'offsets'[1], 'sizes'[1]' // {d,e,f},{g,h,i},{j,k,l}

// Index 'data' at 'offsets'[2], 'sizes'[2]' // {m,n,o},{p,q,r},{s,t,u},{v,w,x}

output_offsets harus di-shard sedemikian rupa sehingga setiap replika memiliki offset dalam perspektif output replika target.

Untuk offset output ke-i, replika saat ini akan mengirimkan update input[input_offsets[i]:input_offsets[i]+input_sizes[i]] ke replika ke-i yang akan ditulis ke output_i[output_offsets[i]:output_offsets[i]+send_sizes[i]] di replika ke-i output.

Misalnya, jika kita memiliki 2 replika:

replica 0:
input: [1, 2, 2]
output:[0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 2]
output_offsets: [0, 0]
recv_sizes: [1, 1]

replica 1:
input: [3, 4, 0]
output: [0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 1]
output_offsets: [1, 2]
recv_sizes: [2, 1]

// replica 0's result will be: [1, 3, 0, 0]
// replica 1's result will be: [2, 2, 4, 0]

HLO all-to-all tidak beraturan memiliki argumen berikut:

• input: tensor data input tidak beraturan.
• output: tensor data output tidak beraturan.
• input_offsets: tensor offset input tidak beraturan.
• send_sizes: tensor ukuran pengiriman yang tidak beraturan.
• output_offsets: array offset tidak beraturan dalam output replika target.
• recv_sizes: tensor ukuran recv tidak beraturan.

Semua tensor *_offsets dan *_sizes harus memiliki bentuk yang sama.

Dua bentuk didukung untuk tensor *_offsets dan *_sizes:

• [num_devices] di mana ragged-all-to-all dapat mengirim paling banyak satu update ke setiap perangkat jarak jauh dalam grup replika. Contoh:

for (remote_device_id : replica_group) {
     SEND input[input_offsets[remote_device_id]],
     output[output_offsets[remote_device_id]],
     send_sizes[remote_device_id] }

• [num_devices, num_updates] di mana ragged-all-to-all dapat mengirim hingga num_updates update ke perangkat jarak jauh yang sama (masing-masing pada offset yang berbeda), untuk setiap perangkat jarak jauh dalam grup replika.

Contoh:

for (remote_device_id : replica_group) {
    for (update_idx : num_updates) {
        SEND input[input_offsets[remote_device_id][update_idx]],
        output[output_offsets[remote_device_id][update_idx]]],
        send_sizes[remote_device_id][update_idx] } }

Dan

Lihat juga XlaBuilder::And.

Melakukan AND per elemen dari dua tensor lhs dan rhs.

And(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran dimensi yang berbeda ada untuk And:

And(lhs,rhs, broadcast_dimensions)

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

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

Untuk mengetahui informasi StableHLO, lihat StableHLO - dan.

Asinkron

Lihat juga HloInstruction::CreateAsyncStart, HloInstruction::CreateAsyncUpdate, HloInstruction::CreateAsyncDone.

AsyncDone, AsyncStart, dan AsyncUpdate adalah petunjuk HLO internal yang digunakan untuk operasi Asinkron dan berfungsi sebagai primitif di HLO. Operasi ini mungkin muncul di dump HLO, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

Atan2

Lihat juga XlaBuilder::Atan2.

Melakukan operasi atan2 per elemen pada lhs dan rhs.

Atan2(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran dimensi yang berbeda ada untuk Atan2:

Atan2(lhs,rhs, broadcast_dimensions)

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

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

Untuk informasi StableHLO, lihat StableHLO - atan2.

BatchNormGrad

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

Menghitung gradien normalisasi batch.

BatchNormGrad(operand, scale, batch_mean, batch_var, grad_output, epsilon, feature_index)

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

Tiga gradien 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 batch_mean dan batch_var merepresentasikan nilai momen di seluruh dimensi batch dan spasial.

Jenis output adalah tuple dari tiga handle:

Untuk informasi StableHLO, lihat StableHLO - batch_norm_grad.

BatchNormInference

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

Menormalisasi 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 dalam operand), operasi menghitung mean dan varians di semua dimensi lainnya dan menggunakan mean dan varians untuk menormalisasi setiap elemen dalam operand. feature_index harus berupa indeks yang valid untuk dimensi fitur dalam operand.

BatchNormInference sama dengan memanggil BatchNormTraining tanpa menghitung mean dan variance untuk setiap batch. Sebagai gantinya, fungsi ini menggunakan input mean dan variance sebagai nilai perkiraan. Tujuan dari operasi ini adalah untuk mengurangi latensi dalam inferensi, sehingga diberi nama BatchNormInference.

Outputnya adalah array yang dinormalisasi berdimensi n dengan bentuk yang sama seperti input operand.

Untuk informasi StableHLO, lihat StableHLO - batch_norm_inference.

BatchNormTraining

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

Menormalisasi 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 dalam operand), operasi menghitung mean dan varians di semua dimensi lainnya dan menggunakan mean dan varians untuk menormalisasi setiap elemen dalam operand. feature_index harus berupa indeks yang valid untuk dimensi fitur dalam operand.

Algoritmanya adalah 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 berupa 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 batch dan dimensi spasial menggunakan formula di atas.

Untuk informasi StableHLO, lihat StableHLO - batch_norm_training.

Bitcast

Lihat juga HloInstruction::CreateBitcast.

Bitcast dapat muncul dalam dump HLO, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

BitcastConvertType

Lihat juga XlaBuilder::BitcastConvertType.

Mirip dengan tf.bitcast di TensorFlow, melakukan operasi bitcast per elemen dari bentuk data ke bentuk target. Ukuran input dan output harus sama: misalnya, elemen s32 menjadi elemen f32 melalui rutin 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 target bentuk harus cocok, terlepas dari dimensi terakhir yang akan berubah berdasarkan rasio ukuran primitif sebelum dan setelah konversi.

Jenis elemen sumber dan tujuan tidak boleh berupa tuple.

Untuk informasi StableHLO, lihat StableHLO - bitcast_convert.

Konversi bitcast ke jenis primitif dengan lebar yang berbeda

Instruksi HLO BitcastConvert mendukung kasus ketika ukuran jenis elemen output T' tidak sama dengan ukuran elemen input T. Karena seluruh operasi secara konseptual adalah 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 paling kecil baru berukuran B/B'. Contoh:

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

Aturannya tetap sama untuk skalar efektif:

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

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

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

Perhatikan bahwa konversi antara bitwidth yang berbeda tidak dilakukan per 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 dalam salinan operand, yaitu

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

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

Untuk mengetahui informasi StableHLO, lihat StableHLO - broadcast.

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 perluasan 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 operand dipetakan ke dimensi broadcast_dimension[i] dari bentuk output. Dimensi operand harus memiliki ukuran 1 atau ukuran yang sama dengan dimensi dalam bentuk output yang dipetakan. Dimensi yang tersisa diisi dengan dimensi berukuran 1. Penyiaran dimensi degenerasi kemudian menyiarkan sepanjang dimensi degenerasi ini untuk mencapai bentuk output. Semantik dijelaskan secara mendetail di halaman penyiaran.

Telepon

Lihat juga XlaBuilder::Call.

Memanggil komputasi dengan argumen yang diberikan.

Call(computation, operands...)

Arity dan jenis operands harus cocok dengan parameter computation. Tidak memiliki operands diizinkan.

CompositeCall

Lihat juga XlaBuilder::CompositeCall.

Merangkum operasi yang terdiri dari (dikomposisikan) operasi StableHLO lainnya, yang menggunakan input dan composite_attributes serta menghasilkan hasil. Semantik op diimplementasikan oleh atribut dekomposisi. Operasi komposit dapat diganti dengan dekomposisinya tanpa mengubah semantik program. Jika penyisipan 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 op 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"
}

CompositeCall(computation, operands..., name, attributes, version)

decomposition op bukan merupakan kolom yang dipanggil, tetapi muncul sebagai atribut to_apply yang mengarah ke fungsi yang berisi penerapan tingkat bawah, yaitu to_apply=%funcname

Informasi selengkapnya tentang komposit dan dekomposisi dapat ditemukan di Spesifikasi StableHLO.

Cbrt

Lihat juga XlaBuilder::Cbrt.

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

Cbrt(operand)

Cbrt juga mendukung argumen result_accuracy opsional:

Cbrt(operand, result_accuracy)

Untuk mengetahui informasi selengkapnya tentang result_accuracy, lihat Akurasi Hasil.

Untuk informasi StableHLO, lihat StableHLO - cbrt.

Ceil

Lihat juga XlaBuilder::Ceil.

Ceil per elemen x -> ⌈x⌉.

Ceil(operand)

Untuk informasi StableHLO, lihat StableHLO - ceil.

Cholesky

Lihat juga XlaBuilder::Cholesky.

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

Cholesky(a, lower)

Jika lower adalah true, menghitung matriks segitiga bawah 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 ditetapkan oleh implementasi dan dapat berupa apa saja.

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

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

Untuk informasi StableHLO, lihat StableHLO - cholesky.

Pembatas

Lihat juga XlaBuilder::Clamp.

Mengepaskan operand dalam rentang antara nilai minimum dan maksimum.

Clamp(min, operand, max)

Mengingat operand dan nilai minimum serta maksimum, menampilkan operand jika berada dalam rentang antara nilai 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 penyiaran yang dibatasi, 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};

Untuk informasi StableHLO, lihat StableHLO - clamp.

Ciutkan

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

Menciutkan dimensi array menjadi satu dimensi.

Collapse(operand, dimensions)

Collapse menggantikan subset dimensi operand tertentu dengan satu dimensi. Argumen input adalah array arbitrer jenis T dan vektor indeks dimensi konstanta waktu kompilasi. Indeks dimensi harus berupa subset berurutan (nomor dimensi rendah ke tinggi) dan berurutan dari dimensi T. Jadi, {0, 1, 2}, {0, 1}, atau {1, 2} adalah semua set dimensi yang valid, tetapi {1, 0} atau {0, 2} tidak valid. Dimensi tersebut digantikan oleh satu dimensi baru, di posisi yang sama dalam urutan dimensi dengan dimensi yang digantikannya, dengan ukuran dimensi baru sama dengan hasil perkalian ukuran dimensi asli. Nomor dimensi terendah di dimensions adalah dimensi yang paling lambat berubah (paling utama) dalam nest loop yang menciutkan dimensi ini, dan nomor dimensi tertinggi adalah yang paling cepat berubah (paling kecil). Lihat operator tf.reshape jika diperlukan pengurutan penciutan yang lebih umum.

Misalnya, misalkan v adalah array 24 elemen:

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

// Collapse to a single dimension, leaving one dimension.
let v012 = Collapse(v, {0,1,2});
then v012 == f32[24] {10, 11, 12, 15, 16, 17,
20, 21, 22, 25, 26, 27,
30, 31, 32, 35, 36, 37,
40, 41, 42, 45, 46, 47};

// Collapse the two lower dimensions, leaving two dimensions.
let v01 = Collapse(v, {0,1});
then v01 == f32[4x6] { {10, 11, 12, 15, 16, 17},
{20, 21, 22, 25, 26, 27},
{30, 31, 32, 35, 36, 37},
{40, 41, 42, 45, 46, 47} };

// Collapse the two higher dimensions, leaving two dimensions.
let v12 = Collapse(v, {1,2});
then v12 == f32[8x3] { {10, 11, 12},
{15, 16, 17},
{20, 21, 22},
{25, 26, 27},
{30, 31, 32},
{35, 36, 37},
{40, 41, 42},
{45, 46, 47} };

Clz

Lihat juga XlaBuilder::Clz.

Menghitung angka nol di depan secara elemen.

Clz(operand)

CollectiveBroadcast

Lihat juga XlaBuilder::CollectiveBroadcast.

Menyiarkan data di seluruh replika. Data dikirim dari ID replika pertama di setiap grup ke ID lain dalam grup yang sama. Jika ID replika tidak ada dalam grup replika mana pun, output pada replika tersebut adalah tensor yang terdiri dari 0 dalam shape.

CollectiveBroadcast(operand, replica_groups, channel_id)

Untuk informasi StableHLO, lihat StableHLO - collective_broadcast.

CollectivePermute

Lihat juga XlaBuilder::CollectivePermute.

CollectivePermute adalah operasi kolektif yang mengirim dan menerima data di seluruh replika.

CollectivePermute(operand, source_target_pairs, channel_id, inplace)

Perhatikan bahwa ada batasan berikut pada source_target_pairs:

• 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(s) dengan bentuk yang sama seperti input.

API operasi CollectivePermute secara internal diuraikan menjadi 2 instruksi HLO (CollectivePermuteStart dan CollectivePermuteDone).

Lihat juga HloInstruction::CreateCollectivePermuteStart.

CollectivePermuteStart dan CollectivePermuteDone berfungsi sebagai primitif di HLO. Operasi ini dapat muncul dalam dump HLO, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

Untuk informasi StableHLO, lihat StableHLO - collective_permute.

Bandingkan

Lihat juga XlaBuilder::Compare.

Melakukan perbandingan berbasis elemen lhs dan rhs berikut:

Eq

Lihat juga XlaBuilder::Eq.

Melakukan perbandingan sama dengan per elemen antara lhs dan rhs.

\(lhs = rhs\)

Eq(lhs, rhs)

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

Ada varian alternatif dengan dukungan penyiaran berdimensi berbeda untuk Eq:

Eq(lhs,rhs, broadcast_dimensions)

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

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

Mendukung total pesanan di atas angka floating point untuk Eq, dengan menerapkan:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

EqTotalOrder(lhs,rhs, broadcast_dimensions)

Untuk informasi StableHLO, lihat StableHLO - compare.

Ne

Lihat juga XlaBuilder::Ne.

Melakukan perbandingan tidak sama dengan per elemen dari lhs dan rhs.

\(lhs != rhs\)

Ne(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran dimensi yang berbeda ada untuk Ne:

Ne(lhs,rhs, broadcast_dimensions)

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

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

Mendukung total pesanan di atas angka floating point untuk Ne, dengan menerapkan:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

NeTotalOrder(lhs,rhs, broadcast_dimensions)

Untuk informasi StableHLO, lihat StableHLO - compare.

Ge

Lihat juga XlaBuilder::Ge.

Melakukan perbandingan greater-or-equal-than per elemen dari lhs dan rhs.

\(lhs >= rhs\)

Ge(lhs, rhs)

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

Tersedia varian alternatif dengan dukungan penyiaran berdimensi berbeda untuk Ge:

Ge(lhs,rhs, broadcast_dimensions)

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

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

Mendukung total pesanan di atas bilangan floating point untuk Gt, dengan menerapkan:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

GtTotalOrder(lhs,rhs, broadcast_dimensions)

Untuk informasi StableHLO, lihat StableHLO - compare.

Gt

Lihat juga XlaBuilder::Gt.

Melakukan perbandingan lebih besar dari per elemen antara lhs dan rhs.

\(lhs > rhs\)

Gt(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran dimensi yang berbeda ada untuk Gt:

Gt(lhs,rhs, broadcast_dimensions)

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

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

Untuk informasi StableHLO, lihat StableHLO - compare.

Le

Lihat juga XlaBuilder::Le.

Melakukan perbandingan less-or-equal-than per elemen dari lhs dan rhs.

\(lhs <= rhs\)

Le(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran dimensi yang berbeda ada untuk Le:

Le(lhs,rhs, broadcast_dimensions)

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

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

Mendukung total pesanan di atas angka floating point untuk Le, dengan menerapkan:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

LeTotalOrder(lhs,rhs, broadcast_dimensions)

Untuk informasi StableHLO, lihat StableHLO - compare.

Lt

Lihat juga XlaBuilder::Lt.

Melakukan perbandingan kurang dari per elemen antara lhs dan rhs.

\(lhs < rhs\)

Lt(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran dimensi yang berbeda ada untuk Lt:

Lt(lhs,rhs, broadcast_dimensions)

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

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

Mendukung total pesanan di atas angka floating point ada untuk Lt, dengan menerapkan:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

LtTotalOrder(lhs,rhs, broadcast_dimensions)

Untuk informasi StableHLO, lihat StableHLO - compare.

Kompleks

Lihat juga XlaBuilder::Complex.

Melakukan konversi per elemen ke nilai kompleks dari pasangan nilai riil dan imajiner, lhs dan rhs.

Complex(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran berdimensi berbeda ada untuk Complex:

Complex(lhs,rhs, broadcast_dimensions)

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

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

Untuk informasi StableHLO, lihat StableHLO - kompleks.

ConcatInDim (Gabungkan)

Lihat juga XlaBuilder::ConcatInDim.

Concatenate menyusun array dari beberapa operan 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 "tidak beraturan". Perhatikan juga bahwa nilai 0 dimensi tidak dapat digabungkan (karena dimensi yang digunakan untuk penggabungan tidak dapat diberi nama).

Contoh 1 dimensi:

Concat({ {2, 3}, {4, 5}, {6, 7} }, 0)
//Output:  {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)

//Output:  { {1, 2},
//          {3, 4},
//          {5, 6},
//          {7, 8} }

Diagram:

Untuk informasi StableHLO, lihat StableHLO - concatenate.

Kondisional

Lihat juga XlaBuilder::Conditional.

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

Menjalankan true_computation jika predicate adalah true, false_computation jika predicate 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 salah satu dari true_computation dan false_computation yang akan dieksekusi, bergantung pada nilai predicate.

Conditional(branch_index, branch_computations, branch_operands)

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

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

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

Untuk mengetahui informasi StableHLO, lihat StableHLO - if.

Konstanta

Lihat juga XlaBuilder::ConstantLiteral.

Menghasilkan output dari literal konstan.

Constant(literal)

Untuk informasi StableHLO, lihat StableHLO - constant.

ConvertElementType

Lihat juga XlaBuilder::ConvertElementType.

Mirip dengan static_cast per elemen di C++, ConvertElementType melakukan operasi konversi per elemen dari bentuk data ke bentuk target. Dimensi harus cocok, dan konversinya adalah per elemen; misalnya, elemen s32 menjadi elemen f32 melalui rutin 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 rutin konversi int-ke-float yang menormalisasi 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}

Untuk informasi StableHLO, lihat StableHLO - convert.

Conv (Konvolusi)

Lihat juga XlaBuilder::Conv.

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

Conv Mengantrekan instruksi konvolusi ke komputasi, yang menggunakan nomor dimensi konvolusi default tanpa dilatasi.

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

Conv(lhs, rhs, window_strides, padding, feature_group_count, batch_group_count, precision_config, preferred_element_type)

Tingkat kontrol yang lebih tinggi tersedia untuk Conv:

• ConvWithGeneralPadding
• ConvWithGeneralDimensions
• ConvGeneral
• ConvGeneralDilated

Misalkan n adalah jumlah dimensi spasial. Argumen lhs adalah array (n+2) dimensi 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 merepresentasikan input independen yang akan dilakukan konvolusinya.
• z/depth/features: Setiap posisi (y,x) di area dasar memiliki vektor yang terkait dengannya, yang masuk ke dimensi ini.
• spatial_dims: Mendeskripsikan dimensi spasial n yang menentukan area dasar tempat jendela bergerak.

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

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

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

Argumen padding menentukan jumlah padding nol yang akan diterapkan ke area dasar. Jumlah padding dapat negatif -- nilai absolut dari 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 3 angka nol di sebelah kanan dalam 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 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.

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

Argumen feature_group_count (nilai default 1) dapat digunakan untuk konvolusi yang dikelompokkan. feature_group_count harus berupa pembagi dimensi fitur input dan output. Jika feature_group_count lebih besar dari 1, berarti 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 subsekuens 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 konvolusi ini digabungkan dalam dimensi fitur output.

Untuk konvolusi per kedalaman, argumen feature_group_count akan disetel ke dimensi fitur input, dan filter akan diubah bentuknya 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 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 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: 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 lhs menjadi batch_group_count grup, 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 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, di mana setiap titik 2D dikaitkan dengan vektor 1D, sehingga kita mendapatkan kotak 3D. Dari kernel konvolusional, karena kita telah menetapkan koordinat output z, kita juga memiliki kotak 3D. Kedua kotak memiliki dimensi yang sama, sehingga kita dapat mengambil jumlah produk per elemen antara kedua kotak (mirip dengan produk dot). Itulah nilai outputnya.

Perhatikan bahwa jika output-z adalah, misalnya, 5, maka setiap posisi jendela menghasilkan 5 nilai dalam output ke dimensi z output. Nilai ini berbeda di bagian kernel konvolusional yang digunakan - ada kotak 3D terpisah dari nilai yang digunakan untuk setiap koordinat output-z. Jadi, Anda dapat menganggapnya sebagai 5 konvolusi terpisah dengan filter yang berbeda untuk masing-masing 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;
}

precision_config digunakan untuk menunjukkan konfigurasi presisi. Tingkat menentukan apakah hardware harus mencoba membuat lebih banyak petunjuk kode mesin untuk memberikan emulasi dtype yang lebih akurat jika diperlukan (yaitu, mengemulasi f32 pada TPU yang hanya mendukung matmul bf16). Nilainya dapat berupa DEFAULT, HIGH, HIGHEST. Detail tambahan di bagian MXU.

preferred_element_type adalah elemen skalar dari jenis output presisi tinggi/rendah yang digunakan untuk akumulasi. preferred_element_type merekomendasikan jenis akumulasi untuk operasi tertentu, tetapi tidak dijamin. Hal ini memungkinkan beberapa backend hardware untuk mengakumulasi dalam jenis yang berbeda dan mengonversi ke jenis output yang diinginkan.

Untuk informasi StableHLO, lihat StableHLO - konvolusi.

ConvWithGeneralPadding

Lihat juga XlaBuilder::ConvWithGeneralPadding.

ConvWithGeneralPadding(lhs, rhs, window_strides, padding, feature_group_count, batch_group_count, precision_config, preferred_element_type)

Sama seperti Conv dengan konfigurasi padding yang eksplisit.

ConvWithGeneralDimensions

Lihat juga XlaBuilder::ConvWithGeneralDimensions.

ConvWithGeneralDimensions(lhs, rhs, window_strides, padding, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type)

Sama seperti Conv dengan angka dimensi yang eksplisit.

ConvGeneral

Lihat juga XlaBuilder::ConvGeneral.

ConvGeneral(lhs, rhs, window_strides, padding, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type)

Sama seperti Conv dengan konfigurasi padding dan angka dimensi yang eksplisit

ConvGeneralDilated

Lihat juga XlaBuilder::ConvGeneralDilated.

ConvGeneralDilated(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type, window_reversal)

Sama seperti Conv dengan konfigurasi padding, faktor dilasi, dan jumlah dimensi yang eksplisit.

Salin

Lihat juga HloInstruction::CreateCopyStart.

Copy secara internal diuraikan menjadi 2 instruksi HLO CopyStart dan CopyDone. Copy bersama dengan CopyStart dan CopyDone berfungsi sebagai primitif di HLO. Operasi ini mungkin muncul dalam dump HLO, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

Cos

Lihat jugaXlaBuilder::Cos.

Kosine per elemen x -> cos(x).

Cos(operand)

Cos juga mendukung argumen result_accuracy opsional:

Cos(operand, result_accuracy)

Untuk mengetahui informasi selengkapnya tentang result_accuracy, lihat Akurasi Hasil.

Untuk mengetahui informasi StableHLO, lihat StableHLO - kosinus.

Cosh

Lihat juga XlaBuilder::Cosh.

Kosinus hiperbolik per elemen x -> cosh(x).

Cosh(operand)

Cosh juga mendukung argumen result_accuracy opsional:

Cosh(operand, result_accuracy)

Untuk mengetahui informasi selengkapnya tentang result_accuracy, lihat Akurasi Hasil.

CustomCall

Lihat juga XlaBuilder::CustomCall.

Panggil fungsi yang disediakan pengguna dalam komputasi.

Dokumentasi CustomCall disediakan di Detail developer - XLA Custom Calls

Untuk informasi StableHLO, lihat StableHLO - custom_call.

Div

Lihat juga XlaBuilder::Div.

Melakukan pembagian per elemen dari dividen lhs dan pembagi rhs.

Div(lhs, rhs)

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

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

Varian alternatif dengan dukungan penyiaran berdimensi berbeda tersedia untuk Div:

Div(lhs,rhs, broadcast_dimensions)

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

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

Untuk informasi StableHLO, lihat StableHLO - divide.

Domain

Lihat juga HloInstruction::CreateDomain.

Domain mungkin muncul dalam dump HLO, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

Titik

Lihat juga XlaBuilder::Dot.

Dot(lhs, rhs, precision_config, preferred_element_type)

Semantik persis dari operasi ini bergantung pada peringkat operan:

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

precision_config digunakan untuk menunjukkan konfigurasi presisi. Tingkat menentukan apakah hardware harus mencoba membuat lebih banyak petunjuk kode mesin untuk memberikan emulasi dtype yang lebih akurat jika diperlukan (yaitu, mengemulasi f32 pada TPU yang hanya mendukung matmul bf16). Nilainya dapat berupa DEFAULT, HIGH, HIGHEST. Detail tambahan di bagian MXU.

preferred_element_type adalah elemen skalar dari jenis output presisi tinggi/rendah yang digunakan untuk akumulasi. preferred_element_type merekomendasikan jenis akumulasi untuk operasi tertentu, tetapi tidak dijamin. Hal ini memungkinkan beberapa backend hardware untuk mengakumulasi dalam jenis yang berbeda dan mengonversi ke jenis output yang diinginkan.

Untuk mengetahui informasi StableHLO, lihat StableHLO - dot.

DotGeneral

Lihat juga XlaBuilder::DotGeneral.

DotGeneral(lhs, rhs, dimension_numbers, precision_config, preferred_element_type)

Mirip dengan Dot, tetapi memungkinkan angka dimensi batch dan kontraksi ditentukan untuk lhs dan rhs.

DotGeneral melakukan penjumlahan produk atas dimensi kontrak yang ditentukan dalam dimension_numbers.

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

Contoh dengan angka dimensi yang menyusut:

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

Dengan demikian, nomor dimensi yang dihasilkan dimulai dengan dimensi batch, kemudian dimensi lhs non-batch/non-kontrak, dan terakhir dimensi rhs non-batch/non-kontrak.

precision_config digunakan untuk menunjukkan konfigurasi presisi. Tingkat menentukan apakah hardware harus mencoba membuat lebih banyak petunjuk kode mesin untuk memberikan emulasi dtype yang lebih akurat jika diperlukan (yaitu, mengemulasi f32 pada TPU yang hanya mendukung matmul bf16). Nilainya dapat berupa DEFAULT, HIGH, HIGHEST. Detail tambahan dapat ditemukan di bagian MXU.

preferred_element_type adalah elemen skalar dari jenis output presisi tinggi/rendah yang digunakan untuk akumulasi. preferred_element_type merekomendasikan jenis akumulasi untuk operasi tertentu, tetapi tidak dijamin. Hal ini memungkinkan beberapa backend hardware untuk mengakumulasi dalam jenis yang berbeda dan mengonversi ke jenis output yang diinginkan.

Untuk mengetahui informasi StableHLO, lihat StableHLO - dot_general.

ScaledDot

Lihat juga XlaBuilder::ScaledDot.

ScaledDot(lhs, lhs_scale, rhs, rhs_scale, dimension_number, precision_config,preferred_element_type)

Mirip dengan DotGeneral.

Membuat operasi dot yang diskalakan dengan operand 'lhs', 'lhs_scale', 'rhs', dan 'rhs_scale', dengan dimensi batch dan kontraksi yang ditentukan dalam 'dimension_numbers'.

RaggedDot

Lihat juga XlaBuilder::RaggedDot.

Untuk perincian komputasi RaggedDot, lihat StableHLO - chlo.ragged_dot

DynamicReshape

Lihat juga XlaBuilder::DynamicReshape.

Operasi ini secara fungsional identik dengan reshape, tetapi bentuk hasil ditentukan secara dinamis melalui output_shape.

DynamicReshape(operand, dim_sizes, new_size_bounds, dims_are_dynamic)

Untuk informasi StableHLO, lihat StableHLO - dynamic_reshape.

DynamicSlice

Lihat juga XlaBuilder::DynamicSlice.

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

DynamicSlice(operand, start_indices, slice_sizes)

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

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

Hal ini memastikan bahwa slice yang diekstrak selalu berada dalam batas array operand. Jika irisan 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});
// Result: {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});
//Result:
// { { 7.0,  8.0},
//   {10.0, 11.0} }

Untuk informasi StableHLO, lihat StableHLO - dynamic_slice.

DynamicUpdateSlice

Lihat juga XlaBuilder::DynamicUpdateSlice.

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

DynamicUpdateSlice(operand, update, start_indices)

Indeks slice efektif dihitung dengan menerapkan transformasi berikut untuk setiap indeks i dalam [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 irisan 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)
// Result: {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)
// Result:
// { {0.0,  1.0,  2.0},
//   {3.0, 12.0, 13.0},
//   {6.0, 14.0, 15.0},
//   {9.0, 16.0, 17.0} }

Untuk informasi StableHLO, lihat StableHLO - dynamic_update_slice.

Erf

Lihat juga XlaBuilder::Erf.

Fungsi error per elemen x -> erf(x) dengan:

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

Erf(operand)

Erf juga mendukung argumen result_accuracy opsional:

Erf(operand, result_accuracy)

Untuk mengetahui informasi selengkapnya tentang result_accuracy, lihat Akurasi Hasil.

Berakhir

Lihat juga XlaBuilder::Exp.

Eksponensial alami per elemen x -> e^x.

Exp(operand)

Exp juga mendukung argumen result_accuracy opsional:

Exp(operand, result_accuracy)

Untuk mengetahui informasi selengkapnya tentang result_accuracy, lihat Akurasi Hasil.

Untuk informasi StableHLO, lihat StableHLO - eksponensial.

Expm1

Lihat juga XlaBuilder::Expm1.

Eksponensial alami per elemen dikurangi satu x -> e^x - 1.

Expm1(operand)

Expm1 juga mendukung argumen result_accuracy opsional:

Expm1(operand, result_accuracy)

Untuk mengetahui informasi selengkapnya tentang result_accuracy, lihat Akurasi Hasil.

Untuk informasi StableHLO, lihat StableHLO - exponential_minus_one.

Fft

Lihat juga XlaBuilder::Fft.

Operasi FFT XLA mengimplementasikan Transformasi Fourier maju dan invers untuk input/output real dan kompleks. FFT multidimensi hingga 3 sumbu didukung.

Fft(operand, ftt_type, fft_length)

Untuk informasi StableHLO, lihat StableHLO - fft.

FFT Multidimensi

Jika lebih dari 1 fft_length diberikan, hal ini setara dengan menerapkan serangkaian operasi FFT ke setiap sumbu paling dalam. Perhatikan bahwa untuk kasus real->kompleks dan kompleks->real, transformasi sumbu paling dalam (secara efektif) dilakukan terlebih dahulu (RFFT; terakhir untuk IRFFT), itulah sebabnya sumbu paling dalam 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.

Lantai

Lihat juga XlaBuilder::Floor.

Floor per elemen x -> ⌊x⌋.

Floor(operand)

Untuk informasi StableHLO, lihat StableHLO - floor.

Fusion

Lihat juga HloInstruction::CreateFusion.

Operasi Fusion merepresentasikan petunjuk HLO dan berfungsi sebagai primitif di HLO. Op ini dapat muncul dalam dump HLO, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

Mengumpulkan

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

Untuk informasi StableHLO, lihat StableHLO - gather.

Semantik Umum

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

gather(operand, start_indices, dimension_numbers, slice_sizes, indices_are_sorted)

Untuk memudahkan, kami memberi label dimensi dalam array output yang tidak ada di offset_dims sebagai batch_dims.

Outputnya 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 belakang (yaitu, jika start_indices berbentuk [6,7] dan index_vector_dim adalah 2, 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 memilih 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 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 yang dihapus).

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

1. Misalkan G = { Out[k] for k in 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 didefinisikan dengan baik meskipun G kosong: Jika G kosong, maka S = start_indices.

2. Buat indeks awal, Sin, ke dalam 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 dalam operand dengan menyebarkan indeks pada dimensi offset di Out sesuai dengan set 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 per elemen.

remapped_offset_dims adalah fungsi monoton dengan domain [0, offset_dims.size) dan rentang [0, operand.rank) \ collapsed_slice_dims. Jadi, 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 disetel ke benar (true), XLA dapat mengasumsikan bahwa start_indices diurutkan (dalam urutan menaik, setelah menyebarkan nilainya sesuai dengan start_index_map) oleh pengguna. Jika tidak, semantiknya ditentukan oleh implementasi.

Deskripsi dan Contoh Tidak Resmi

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 "penuh" ke dalam operand.

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

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

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

index_vector_dim disetel ke start_indices.rank - 1 di semua contoh berikutnya. Nilai index_vector_dim yang lebih menarik 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 berbentuk S64[2], sehingga kumpulan 5 posisi dapat direpresentasikan sebagai array S64[5,2].

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

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

slice_sizes adalah [8,6], yang menentukan rentang O₀ dan O₁, dan ini pada gilirannya menentukan batas irisan.

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

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

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

Operasi pengumpulan di XLA menggeneralisasi 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 daripada jumlah dimensi input. Dimensi "yang tidak ada" ini, yang tercantum secara eksplisit sebagai collapsed_slice_dims, harus memiliki ukuran irisan 1. Karena memiliki ukuran slice 1, satu-satunya indeks yang valid untuknya adalah 0 dan menghilangkannya tidak menimbulkan ambiguitas.

3. Slice yang diekstrak dari array "Kumpulkan Indeks" ((X, Y) dalam contoh terakhir) mungkin memiliki lebih sedikit elemen daripada jumlah dimensi array input, dan pemetaan eksplisit menentukan cara indeks harus 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 "Gather Index Mapping" (start_index_map dalam deskripsi formal) dan "Offset Mapping" (remapped_offset_dims dalam deskripsi formal) menjadi [X,0] dan [0,O0], masing-masing, sehingga menghasilkan [X,O0]. Dengan kata lain, indeks output [G0,G1,O0] dipetakan ke indeks input [GatherIndices[G0,G1,0],O0] yang memberikan 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)

Untuk informasi StableHLO, lihat StableHLO - get_dimension_size.

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.

GetTupleElement(tuple_data, index)

Untuk informasi StableHLO, lihat StableHLO - get_tuple_element.

Imag

Lihat juga XlaBuilder::Imag.

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

Imag(operand)

Untuk informasi StableHLO, lihat StableHLO - imag.

Dalam feed

Lihat juga XlaBuilder::Infeed.

Infeed(shape, config)

Membaca satu item data dari antarmuka streaming In-feed implisit perangkat, menafsirkan data sebagai bentuk dan tata letaknya yang diberikan, serta menampilkan XlaOp data. Beberapa operasi Infeed diizinkan dalam komputasi, tetapi harus ada total urutan 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 melakukan apa pun dan berlanjut tanpa membaca data apa pun dari Infeed perangkat.

Untuk informasi StableHLO, lihat StableHLO - in-feed.

Iota

Lihat juga XlaBuilder::Iota.

Iota(shape, iota_dimension)

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

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

Untuk mengetahui informasi StableHLO, lihat StableHLO - iota.

IsFinite

Lihat juga XlaBuilder::IsFinite.

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

IsFinite(operand)

Untuk informasi StableHLO, lihat StableHLO - is_finite.

Log

Lihat juga XlaBuilder::Log.

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

Log(operand)

Log juga mendukung argumen result_accuracy opsional:

Log(operand, result_accuracy)

Untuk mengetahui informasi selengkapnya tentang result_accuracy, lihat Akurasi Hasil.

Untuk informasi StableHLO, lihat StableHLO - log.

Log1p

Lihat juga XlaBuilder::Log1p.

Logaritma natural yang diubah menurut elemen x -> ln(1+x).

Log1p(operand)

Log1p juga mendukung argumen result_accuracy opsional:

Log1p(operand, result_accuracy)

Untuk mengetahui informasi selengkapnya tentang result_accuracy, lihat Akurasi Hasil.

Untuk informasi StableHLO, lihat StableHLO - log_plus_one.

Logistik

Lihat juga XlaBuilder::Logistic.

Penghitungan fungsi logistik per elemen x -> logistic(x).

Logistic(operand)

Logistic juga mendukung argumen result_accuracy opsional:

Logistic(operand, result_accuracy)

Untuk mengetahui informasi selengkapnya tentang result_accuracy, lihat Akurasi Hasil.

Untuk mengetahui informasi StableHLO, lihat StableHLO - logistik.

Peta

Lihat juga XlaBuilder::Map.

Map(operands..., computation, dimensions)

Menerapkan fungsi skalar pada array operands yang diberikan, menghasilkan array dengan dimensi yang sama di mana 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 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.

Untuk informasi StableHLO, lihat StableHLO - map.

Maks

Lihat juga XlaBuilder::Max.

Melakukan operasi maks per elemen pada tensor lhs dan rhs.

Max(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran berdimensi berbeda tersedia untuk Max:

Max(lhs,rhs, broadcast_dimensions)

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

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

Untuk informasi StableHLO, lihat StableHLO - maksimum.

Min

Lihat juga XlaBuilder::Min.

Melakukan operasi min per elemen pada lhs dan rhs.

Min(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran berdimensi berbeda ada untuk Min:

Min(lhs,rhs, broadcast_dimensions)

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

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

Untuk mengetahui informasi StableHLO, lihat StableHLO - minimum.

Mul

Lihat juga XlaBuilder::Mul.

Melakukan perkalian per elemen lhs dan rhs.

Mul(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran dimensi yang berbeda ada untuk Mul:

Mul(lhs,rhs, broadcast_dimensions)

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

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

Untuk informasi StableHLO, lihat StableHLO - multiply.

Neg

Lihat juga XlaBuilder::Neg.

Negasi per elemen x -> -x.

Neg(operand)

Untuk informasi StableHLO, lihat StableHLO - negate

Tidak

Lihat juga XlaBuilder::Not.

Logika not x -> !(x) per elemen.

Not(operand)

Untuk informasi StableHLO, lihat StableHLO - not.

OptimizationBarrier

Lihat juga XlaBuilder::OptimizationBarrier.

Mencegah semua proses pengoptimalan memindahkan komputasi melintasi penghalang.

OptimizationBarrier(operand)

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

Untuk informasi StableHLO, lihat StableHLO - optimization_barrier.

Atau

Lihat juga XlaBuilder::Or.

Melakukan OR per elemen lhs dan rhs .

Or(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran dimensi yang berbeda ada untuk Or:

Or(lhs,rhs, broadcast_dimensions)

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

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

Untuk mengetahui informasi StableHLO, lihat StableHLO - or.

Keluar

Lihat juga XlaBuilder::Outfeed.

Menulis input ke outfeed.

Outfeed(operand, shape_with_layout, outfeed_config)

shape_with_layout mengomunikasikan bentuk yang telah diatur yang ingin kita keluarkan.

Untuk mengetahui informasi StableHLO, lihat StableHLO - outfeed.

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 ujung bawah (di samping indeks 0) dan ujung atas (di samping indeks tertinggi) dari setiap dimensi. Jumlah padding tepi dapat negatif -- nilai absolut dari padding negatif menunjukkan jumlah elemen yang akan dihapus dari dimensi yang ditentukan.

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

Operasi ini tidak akan melakukan apa pun 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.

Untuk informasi StableHLO, lihat StableHLO - pad.

Parameter

Lihat juga XlaBuilder::Parameter.

Parameter merepresentasikan input argumen ke komputasi.

PartitionID

Lihat juga XlaBuilder::BuildPartitionId.

Menghasilkan partition_id dari proses saat ini.

PartitionID(shape)

PartitionID dapat muncul dalam dump HLO, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

Untuk informasi StableHLO, lihat StableHLO - partition_id.

PopulationCount

Lihat juga XlaBuilder::PopulationCount.

Menghitung jumlah bit yang ditetapkan di setiap elemen operand.

PopulationCount(operand)

Untuk informasi StableHLO, lihat StableHLO - popcnt.

Pow

Lihat juga XlaBuilder::Pow.

Melakukan eksponensiasi per elemen lhs dengan rhs.

Pow(lhs, rhs)

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

Varian alternatif dengan dukungan penyiaran berdimensi berbeda tersedia untuk Pow:

Pow(lhs,rhs, broadcast_dimensions)

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

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

Untuk mengetahui informasi StableHLO, lihat StableHLO - power.

Real

Lihat juga XlaBuilder::Real.

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

Real(operand)

Untuk mengetahui informasi StableHLO, lihat StableHLO - real.

Recv

Lihat juga XlaBuilder::Recv.

Recv, RecvWithTokens, dan RecvToHost adalah operasi yang berfungsi sebagai primitif komunikasi di HLO. Operasi ini biasanya muncul dalam dump HLO sebagai bagian dari input/output tingkat rendah atau transfer lintas perangkat, tetapi tidak dimaksudkan untuk dibuat secara manual oleh pengguna akhir.

Recv(shape, handle)

Menerima data dengan bentuk tertentu dari instruksi Send dalam komputasi lain yang menggunakan handle channel yang sama. Menampilkan XlaOp untuk data yang diterima.

Untuk informasi StableHLO, lihat StableHLO - recv.

RecvDone

Lihat juga HloInstruction::CreateRecv dan HloInstruction::CreateRecvDone.

Mirip dengan Send, API klien operasi Recv merepresentasikan komunikasi sinkron. Namun, petunjuk ini didekomposisi secara internal menjadi 2 petunjuk HLO (Recv dan RecvDone) untuk mengaktifkan transfer data asinkron.

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 instruksi RecvDone berikutnya untuk menunggu penyelesaian transfer data. Konteks adalah tuple {buffer penerima (bentuk), ID permintaan (U32)} dan hanya dapat digunakan oleh instruksi RecvDone.

Mengingat konteks yang dibuat oleh instruksi 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_to_reduce)

Dengan:

• N harus lebih besar atau sama dengan 1.
• Komputasi harus bersifat asosiatif "secara kasar" (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 elemen N berjenis T.

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

Backend yang berbeda diizinkan untuk mengaitkan kembali komputasi pengurangan. Hal ini dapat menyebabkan perbedaan numerik, karena beberapa fungsi reduksi seperti penambahan tidak asosiatif untuk float. Namun, jika rentang datanya terbatas, penambahan bilangan floating point cukup dekat untuk menjadi asosiatif bagi sebagian besar penggunaan praktis.

Untuk informasi StableHLO, lihat StableHLO - reduce.

Contoh

Saat merampingkan satu dimensi dalam satu array 1D dengan nilai [10, 11, 12, 13], dengan fungsi perampingan 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 lain, 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 penerapan reduksi, menggunakan penjumlahan sebagai komputasi reduksi 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 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 reduksi adalah array 1D. Diagram menampilkan satu sebagai kolom dan yang lain sebagai baris hanya untuk kemudahan 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. Agar lebih sederhana, nilai 1 hingga 6 direplikasi di seluruh dimensi 0.

Mirip dengan contoh 2D, kita dapat mengurangi hanya satu dimensi. Jika kita mengurangi dimensi 0, misalnya, kita akan mendapatkan array 2 dimensi dengan semua nilai di dimensi 0 dilipat menjadi skalar:

|  4   8  12 |
| 16  20  24 |

Jika kita 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 dapat diberi nomor baru (karena jumlah dimensi berubah).

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

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

Variadic Reduce

Saat N > 1, penerapan fungsi reduce sedikit lebih rumit, 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 operan ke-N

Misalnya, pertimbangkan fungsi pengurangan berikut, yang dapat digunakan untuk menghitung maks dan argmaks 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 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 berulang bersama-sama di seluruh array, dan menampilkan tuple yang berisi nilai maksimum dan indeks yang cocok.

ReducePrecision

Lihat juga XlaBuilder::ReducePrecision.

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

ReducePrecision(operand, exponent_bits, mantissa_bits)

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

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

Untuk informasi StableHLO, lihat StableHLO - reduce_precision.

ReduceScatter

Lihat juga XlaBuilder::ReduceScatter.

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

ReduceScatter(operand, computation, scatter_dimension, shard_count, replica_groups, channel_id, layout, use_global_device_ids)

• Jika operand adalah tuple array, reduce-scatter dilakukan pada setiap elemen tuple.
• replica_groups adalah daftar grup replika yang di antaranya pengurangan dilakukan (ID replika untuk replika saat ini dapat diambil menggunakan ReplicaId). Urutan replika di setiap grup menentukan urutan hasil all-reduce akan disebarkan. 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 reduksi antara replika 0 dan 2, serta 1 dan 3, lalu menyebarkan hasilnya.
• shard_count adalah ukuran setiap grup replika. Kami 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 berkomunikasi satu sama lain.
• layout Lihat xla::shapes untuk mengetahui informasi selengkapnya tentang tata letak.
• use_global_device_ids adalah tanda yang ditentukan pengguna. Jika false(default), angka dalam replica_groups adalah ReplicaId saat true, replica_groups mewakili ID global (ReplicaID*partition_count + partition_id). Misalnya:
  • Dengan 2 replika dan 4 partisi,
  • replica_groups={ {0,1,4,5},{2,3,6,7} } and use_global_device_ids=true
  • group[0] = (0,0), (0,1), (1,0), (1,1)
  • group[1] = (0,2), (0,3), (1,2), (1,3)
  • dengan setiap pasangan adalah (replica_id, partition_id).

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

Untuk informasi StableHLO, lihat StableHLO - reduce_scatter.

ReduceScatter - Contoh 1 - StableHLO

Pada contoh di atas, ada 2 replika yang berpartisipasi dalam ReduceScatter. Pada setiap replika, operand memiliki bentuk f32[2,4]. Semua pengurangan (jumlah) dilakukan di seluruh replika, sehingga menghasilkan nilai yang dikurangi dengan bentuk f32[2,4] di setiap replika. Nilai yang dikurangi ini kemudian dibagi menjadi 2 bagian di sepanjang dimensi 1, sehingga setiap bagian memiliki bentuk f32[2,2]. Setiap replika dalam grup proses menerima bagian yang sesuai dengan posisinya dalam grup. Akibatnya, output pada setiap replika memiliki bentuk f32[2,2].

ReduceWindow

Lihat juga XlaBuilder::ReduceWindow.

Menerapkan fungsi reduksi ke semua elemen di setiap jendela dari urutan N array multidimensi, 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. Mirip dengan Reduce, computation yang diterapkan selalu diteruskan ke init_values di sisi kiri.

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

Dengan:

• 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 elemen N berjenis (T0,...T{N-1}).

Untuk informasi StableHLO, lihat StableHLO - reduce_window.

ReduceWindow - Contoh 1

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