Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Semantik penyiaran

Dokumen ini menjelaskan bagaimana semantik penyiaran dalam XLA bekerja.

Apa itu siaran?

Broadcasting adalah proses pembuatan array dengan berbagai bentuk memiliki bentuk yang kompatibel untuk operasi aritmatika. Terminologi ini dipinjam dari siaran Numpy.

Penyiaran mungkin diperlukan untuk operasi antara array multi-dimensi dari peringkat yang berbeda, atau antara array multi-dimensi dengan bentuk yang berbeda namun kompatibel. Pertimbangkan penambahan X+v mana X adalah matriks (array peringkat 2) dan v adalah vektor (array peringkat 1). Untuk melakukan penambahan elemen-bijaksana, XLA perlu "menyiarkan" vektor v ke peringkat yang sama dengan matriks X , dengan mereplikasi v beberapa kali. Panjang vektor harus cocok dengan setidaknya satu dimensi dari matriks.

Sebagai contoh:

 |1 2 3| + |7 8 9|
|4 5 6|
 

Dimensi matriks adalah (2,3), vektor adalah (3). Vektor disiarkan dengan mereplikasi pada baris untuk mendapatkan:

 |1 2 3| + |7 8 9| = |8  10 12|
|4 5 6|   |7 8 9|   |11 13 15|
 

Dalam Numpy, ini disebut penyiaran .

Prinsip

Bahasa XLA seketat dan sejelas mungkin, menghindari fitur implisit dan "ajaib". Fitur-fitur tersebut dapat membuat beberapa perhitungan sedikit lebih mudah untuk didefinisikan, dengan biaya asumsi yang lebih besar dimasukkan ke dalam kode pengguna yang akan sulit diubah dalam jangka panjang. Jika perlu, fitur implisit dan magis dapat ditambahkan dalam pembungkus tingkat klien.

Berkenaan dengan penyiaran, diperlukan spesifikasi penyiaran eksplisit tentang operasi di antara susunan peringkat yang berbeda. Ini berbeda dari Numpy, yang menyimpulkan spesifikasi bila memungkinkan.

Menyiarkan array peringkat rendah ke array peringkat lebih tinggi

Skalar selalu dapat disiarkan melalui array tanpa spesifikasi eksplisit dari dimensi penyiaran. Operasi biner elemen-bijaksana antara skalar dan array berarti menerapkan operasi dengan skalar untuk setiap elemen dalam array. Misalnya, menambahkan skalar ke matriks berarti menghasilkan matriks yang setiap elemennya merupakan jumlah skalar dengan elemen matriks input yang sesuai.

 |1 2 3| + 7 = |8  9  10|
|4 5 6|       |11 12 13|
 

Sebagian besar kebutuhan penyiaran dapat ditangkap dengan menggunakan tuple dimensi pada operasi biner. Ketika input untuk operasi memiliki peringkat yang berbeda, tuple penyiaran ini menentukan dimensi mana dalam array peringkat yang lebih tinggi yang cocok dengan array peringkat yang lebih rendah .

Pertimbangkan contoh sebelumnya, alih-alih menambahkan skalar ke matriks (2,3), tambahkan vektor dimensi (3) ke matriks dimensi (2,3). Tanpa menentukan siaran, operasi ini tidak valid. Untuk meminta penambahan matriks-vektor dengan benar, tentukan dimensi penyiaran menjadi (1), artinya dimensi vektor disesuaikan dengan dimensi 1 dari matriks. Dalam 2D, jika dimensi 0 dianggap sebagai baris dan dimensi 1 sebagai kolom, ini berarti bahwa setiap elemen vektor menjadi kolom dengan ukuran yang cocok dengan jumlah baris dalam matriks:

 |7 8 9| ==> |7 8 9|
            |7 8 9|
 

Sebagai contoh yang lebih kompleks, pertimbangkan untuk menambahkan vektor 3 elemen (dimensi (3)) ke matriks 3x3 (dimensi (3,3)). Ada dua cara penyiaran dapat terjadi untuk contoh ini:

(1) Dimensi penyiaran 1 dapat digunakan. Setiap elemen vektor menjadi kolom dan vektor diduplikasi untuk setiap baris dalam matriks.

 |7 8 9| ==> |7 8 9|
            |7 8 9|
            |7 8 9|
 

(2) Dimensi penyiaran 0 dapat digunakan. Setiap elemen vektor menjadi baris dan vektor diduplikasi untuk setiap kolom dalam matriks.

  |7| ==> |7 7 7|
 |8|     |8 8 8|
 |9|     |9 9 9|
 

Dimensi penyiaran dapat berupa tupel yang menjelaskan bagaimana bentuk peringkat yang lebih kecil disiarkan ke dalam bentuk peringkat yang lebih besar. Misalnya, diberi kubus 2x3x4 dan matriks 3x4, tuple penyiaran (1,2) berarti mencocokkan matriks dengan dimensi 1 dan 2 kuboid.

Jenis siaran ini digunakan dalam operasi biner di XlaBuilder , jika argumen broadcast_dimensions diberikan. Misalnya, lihat XlaBuilder :: Add . Dalam kode sumber XLA, jenis siaran ini kadang-kadang disebut siaran "InDim".

Definisi formal

Atribut penyiaran memungkinkan pencocokan array peringkat rendah ke array peringkat lebih tinggi, dengan menentukan dimensi array peringkat lebih tinggi mana yang cocok. Misalnya, untuk array dengan dimensi MxNxPxQ, vektor dengan dimensi T dapat dicocokkan sebagai berikut:

           MxNxPxQ

dim 3:          T
dim 2:        T
dim 1:      T
dim 0:    T
 

Dalam setiap kasus, T harus sama dengan dimensi pencocokan array peringkat yang lebih tinggi. Nilai vektor kemudian disiarkan dari dimensi yang cocok ke semua dimensi lainnya.

Untuk mencocokkan matriks TxV ke array MxNxPxQ, sepasang dimensi penyiaran digunakan:

           MxNxPxQ
dim 2,3:      T V
dim 1,2:    T V
dim 0,3:  T     V
etc...
 

Urutan dimensi dalam tuple penyiaran harus menjadi urutan di mana dimensi array peringkat rendah diharapkan sesuai dengan dimensi array peringkat yang lebih tinggi. Elemen pertama dalam tuple mengatakan dimensi mana dalam array peringkat lebih tinggi harus cocok dengan dimensi 0 dalam array peringkat lebih rendah. Elemen kedua untuk dimensi 1, dan seterusnya. Urutan dimensi siaran harus benar-benar meningkat. Misalnya, dalam contoh sebelumnya adalah ilegal untuk mencocokkan V ke N dan T ke P; itu juga ilegal untuk mencocokkan V ke P dan N.

Menyiarkan array peringkat serupa dengan dimensi yang memburuk

Masalah penyiaran terkait adalah penyiaran dua array yang memiliki peringkat yang sama tetapi ukuran dimensi yang berbeda. Demikian pula dengan aturan Numpy, ini hanya dimungkinkan ketika array kompatibel . Dua array kompatibel ketika semua dimensinya kompatibel. Dua dimensi kompatibel jika:

  • Mereka sama, atau
  • Salah satunya adalah 1 (dimensi "merosot")

Ketika dua array yang kompatibel ditemukan, bentuk hasil memiliki maksimum di antara dua input di setiap indeks dimensi.

Contoh:

  1. (2,1) dan (2,3) disiarkan ke (2,3).
  2. (1,2,5) dan (7,2,5) disiarkan ke (7,2,5)
  3. (7,2,5) dan (7,1,5) disiarkan ke (7,2,5)
  4. (7,2,5) dan (7,2,6) tidak kompatibel dan tidak dapat disiarkan.

Kasus khusus muncul, dan juga didukung, di mana setiap array input memiliki dimensi yang merosot pada indeks yang berbeda. Dalam hal ini, hasilnya adalah "operasi luar": (2,1) dan (1,3) disiarkan ke (2,3). Untuk lebih banyak contoh, lihat dokumentasi Numpy tentang penyiaran .

Komposisi siaran

Penyiaran dari array peringkat rendah ke array peringkat lebih tinggi dan penyiaran menggunakan dimensi degenerasi dapat dilakukan dalam operasi biner yang sama. Misalnya, vektor ukuran 4 dan matriks ukuran 1x2 dapat ditambahkan bersama-sama menggunakan nilai dimensi siaran dari (0):

 |1 2 3 4| + [5 6]    // [5 6] is a 1x2 matrix, not a vector.
 

Pertama vektor disiarkan ke peringkat 2 (matriks) menggunakan dimensi siaran. Nilai tunggal (0) dalam dimensi siaran menunjukkan bahwa dimensi nol dari vektor cocok dengan dimensi nol dari matriks. Ini menghasilkan matriks ukuran 4xM di mana nilai M dipilih untuk mencocokkan ukuran dimensi yang sesuai dalam array 1x2. Oleh karena itu, matriks 4x2 dihasilkan:

 |1 1| + [5 6]
|2 2|
|3 3|
|4 4|
 

Lalu "degenerate dimensional broadcasting" menyiarkan dimensi nol dari matriks 1x2 agar sesuai dengan ukuran dimensi yang sesuai di sisi kanan:

 |1 1| + |5 6|     |6  7|
|2 2| + |5 6|  =  |7  8|
|3 3| + |5 6|     |8  9|
|4 4| + |5 6|     |9 10|
 

Contoh yang lebih rumit adalah matriks ukuran 1x2 ditambahkan ke array ukuran 4x3x1 menggunakan dimensi siaran (1, 2). Pertama matriks 1x2 disiarkan ke peringkat 3 menggunakan dimensi siaran untuk menghasilkan array Mx1x2 menengah di mana ukuran dimensi M ditentukan oleh ukuran operan yang lebih besar (array 4x3x1) menghasilkan array perantara 4x1x2. M berada pada dimensi 0 (dimensi paling kiri) karena dimensi 1 dan 2 dipetakan ke dimensi matriks 1x2 asli sebagaimana dimensi siarannya (1, 2). Array perantara ini dapat ditambahkan ke matriks 4x3x1 menggunakan siaran dimensi degenerate untuk menghasilkan hasil array 4x3x2.