Istilah penyiaran menjelaskan bagaimana NumPy memperlakukan array dengan bentuk berbeda selama operasi aritmatika. Tunduk pada batasan tertentu, larik yang lebih kecil "disiarkan" ke larik yang lebih besar sehingga mereka memiliki bentuk yang kompatibel. Broadcasting menyediakan cara untuk memvektorisasi operasi array sehingga perulangan terjadi di C alih-alih Python. Ini dilakukan tanpa membuat salinan data yang tidak perlu dan biasanya menghasilkan implementasi algoritme yang efisien. Namun, ada kasus di mana penyiaran adalah ide yang buruk karena menyebabkan penggunaan memori yang tidak efisien sehingga memperlambat perhitungan
Operasi NumPy biasanya dilakukan pada pasangan array berdasarkan elemen demi elemen. Dalam kasus yang paling sederhana, kedua larik harus memiliki bentuk yang persis sama, seperti pada contoh berikut
>>> a = np.array([1.0, 2.0, 3.0]) >>> b = np.array([2.0, 2.0, 2.0]) >>> a * b array([2., 4., 6.])
Aturan penyiaran NumPy melonggarkan batasan ini ketika bentuk array memenuhi batasan tertentu. Contoh penyiaran paling sederhana terjadi ketika sebuah array dan nilai skalar digabungkan dalam sebuah operasi
>>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) _
Hasilnya setara dengan contoh sebelumnya di mana >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) 2 adalah sebuah array. Kita dapat memikirkan skalar >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) _2 yang diregangkan selama operasi aritmatika menjadi larik dengan bentuk yang sama dengan >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) 4. Elemen baru di >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) 2, seperti yang ditunjukkan di , hanyalah salinan dari skalar asli. Analogi peregangan hanya bersifat konseptual. NumPy cukup pintar untuk menggunakan nilai skalar asli tanpa benar-benar membuat salinan sehingga operasi penyiaran adalah sebagai memori dan seefisien mungkin secara komputasi
Gambar 1
Dalam contoh penyiaran yang paling sederhana, skalar >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) 2 direntangkan menjadi larik dengan bentuk yang sama dengan >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) 4 sehingga bentuknya kompatibel untuk perkalian elemen demi elemen
Kode pada contoh kedua lebih efisien daripada yang pertama karena penyiaran memindahkan lebih sedikit memori selama perkalian (>>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) 2 adalah skalar daripada larik)
Aturan Penyiaran Umum
Saat beroperasi pada dua larik, NumPy membandingkan bentuknya berdasarkan elemen. Ini dimulai dengan trailing (i. e. paling kanan) dimensi dan bekerja dengan cara kiri. Dua dimensi kompatibel saat
mereka sama, atau
salah satunya adalah 1
Jika kondisi ini tidak terpenuhi, pengecualian >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) _9 dilemparkan, menunjukkan bahwa array memiliki bentuk yang tidak kompatibel
Array input tidak perlu memiliki jumlah dimensi yang sama. Array yang dihasilkan akan memiliki jumlah dimensi yang sama dengan array input dengan jumlah dimensi terbesar, di mana ukuran setiap dimensi adalah ukuran terbesar dari dimensi yang sesuai di antara array input. Perhatikan bahwa dimensi yang hilang diasumsikan memiliki ukuran satu
Misalnya, jika Anda memiliki Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 _0 larik nilai RGB, dan Anda ingin menskalakan setiap warna pada gambar dengan nilai yang berbeda, Anda dapat mengalikan gambar dengan larik satu dimensi dengan 3 nilai. Menyejajarkan ukuran sumbu belakang dari larik ini sesuai dengan aturan penyiaran, menunjukkan bahwa keduanya kompatibel
Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3
Ketika salah satu dimensi dibandingkan adalah satu, yang lain digunakan. Dengan kata lain, dimensi dengan ukuran 1 direntangkan atau "disalin" agar sesuai dengan yang lain
Dalam contoh berikut, array Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 _1 dan Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 2 memiliki sumbu dengan panjang satu yang diperluas ke ukuran yang lebih besar selama operasi siaran
A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5
Array yang dapat disiarkan
Satu set array disebut "dapat disiarkan" ke bentuk yang sama jika aturan di atas menghasilkan hasil yang valid
Misalnya, jika Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 3 adalah (5,1), Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 4 adalah (1,6), Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 5 adalah (6,) dan Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 6 adalah () sehingga d adalah skalar, maka a, b, c, dan d semuanya dapat disiarkan
a bertindak seperti (5,6) array di mana Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 7 disiarkan ke kolom lain,
b bertindak seperti (5,6) array di mana Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 8 disiarkan ke baris lain,
c bertindak seperti larik (1,6) dan karena itu seperti larik (5,6) di mana Image (3d array): 256 x 256 x 3 Scale (1d array): 3 Result (3d array): 256 x 256 x 3 9 disiarkan ke setiap baris, dan akhirnya,
d bertindak seperti larik (5,6) di mana nilai tunggal diulang
Berikut beberapa contoh lainnya
A (2d array): 5 x 4 B (1d array): 1 Result (2d array): 5 x 4 A (2d array): 5 x 4 B (1d array): 4 Result (2d array): 5 x 4 A (3d array): 15 x 3 x 5 B (3d array): 15 x 1 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 1 Result (3d array): 15 x 3 x 5
Berikut adalah contoh bentuk yang tidak disiarkan
A (1d array): 3 B (1d array): 4 # trailing dimensions do not match A (2d array): 2 x 1 B (3d array): 8 x 4 x 3 # second from last dimensions mismatched
Contoh penyiaran ketika array 1-d ditambahkan ke array 2-d
>>> a = np.array([[ 0.0, 0.0, 0.0], .. [10.0, 10.0, 10.0], .. [20.0, 20.0, 20.0], .. [30.0, 30.0, 30.0]]) >>> b = np.array([1.0, 2.0, 3.0]) >>> a + b array([[ 1., 2., 3.], [11., 12., 13.], [21., 22., 23.], [31., 32., 33.]]) >>> b = np.array([1.0, 2.0, 3.0, 4.0]) >>> a + b Traceback (most recent call last): ValueError: operands could not be broadcast together with shapes (4,3) (4,)
Seperti yang ditunjukkan pada , >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) _2 ditambahkan ke setiap baris >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) 4. Di , pengecualian dimunculkan karena bentuk yang tidak kompatibel
Gambar 2
Array satu dimensi yang ditambahkan ke array dua dimensi menghasilkan penyiaran jika jumlah elemen array 1-d cocok dengan jumlah kolom array 2-d
Gambar 3
Ketika dimensi akhir dari larik tidak sama, penyiaran gagal karena tidak mungkin menyelaraskan nilai di baris larik pertama dengan elemen larik ke-2 untuk penambahan elemen demi elemen
Penyiaran menyediakan cara yang nyaman untuk mengambil produk luar (atau operasi luar lainnya) dari dua larik. Contoh berikut menunjukkan operasi penjumlahan luar dari dua larik 1-d
>>> a = np.array([0.0, 10.0, 20.0, 30.0]) >>> b = np.array([1.0, 2.0, 3.0]) >>> a[:, np.newaxis] + b array([[ 1., 2., 3.], [11., 12., 13.], [21., 22., 23.], [31., 32., 33.]])
Gambar 4
Dalam beberapa kasus, penyiaran merentangkan kedua larik untuk membentuk larik keluaran yang lebih besar dari salah satu larik awal
Di sini operator indeks A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5 _2 menyisipkan sumbu baru ke dalam >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) 4, menjadikannya larik A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5 4 dua dimensi. Menggabungkan larik A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5 4 dengan >>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) 2, yang berbentuk A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5 7, menghasilkan larik A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5 8
Contoh Praktis. Kuantisasi Vektor
Penyiaran muncul cukup sering dalam masalah dunia nyata. Contoh tipikal terjadi pada algoritma kuantisasi vektor (VQ) yang digunakan dalam teori informasi, klasifikasi, dan area terkait lainnya. Operasi dasar dalam VQ menemukan titik terdekat dalam sekumpulan titik, disebut A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5 9 dalam jargon VQ, ke titik tertentu, disebut A (2d array): 5 x 4 B (1d array): 1 Result (2d array): 5 x 4 A (2d array): 5 x 4 B (1d array): 4 Result (2d array): 5 x 4 A (3d array): 15 x 3 x 5 B (3d array): 15 x 1 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 1 Result (3d array): 15 x 3 x 5 0. Dalam kasus dua dimensi yang sangat sederhana yang ditunjukkan di bawah ini, nilai dalam A (2d array): 5 x 4 B (1d array): 1 Result (2d array): 5 x 4 A (2d array): 5 x 4 B (1d array): 4 Result (2d array): 5 x 4 A (3d array): 15 x 3 x 5 B (3d array): 15 x 1 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 1 Result (3d array): 15 x 3 x 5 0 menggambarkan berat dan tinggi seorang atlet yang akan diklasifikasikan. A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5 _9 mewakili kelas atlet yang berbeda. Menemukan titik terdekat membutuhkan penghitungan jarak antara observasi dan masing-masing kode. Jarak terpendek memberikan kecocokan terbaik. Dalam contoh ini, A (2d array): 5 x 4 B (1d array): 1 Result (2d array): 5 x 4 A (2d array): 5 x 4 B (1d array): 4 Result (2d array): 5 x 4 A (3d array): 15 x 3 x 5 B (3d array): 15 x 1 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 1 Result (3d array): 15 x 3 x 5 _3 adalah kelas terdekat yang menunjukkan bahwa atlet kemungkinan adalah pemain bola basket
>>> from numpy import array, argmin, sqrt, sum >>> observation = array([111.0, 188.0]) >>> codes = array([[102.0, 203.0], .. [132.0, 193.0], .. [45.0, 155.0], .. [57.0, 173.0]]) >>> diff = codes - observation # the broadcast happens here >>> dist = sqrt(sum(diff**2,axis=-1)) >>> argmin(dist) 0
Dalam contoh ini, larik A (2d array): 5 x 4 B (1d array): 1 Result (2d array): 5 x 4 A (2d array): 5 x 4 B (1d array): 4 Result (2d array): 5 x 4 A (3d array): 15 x 3 x 5 B (3d array): 15 x 1 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 1 Result (3d array): 15 x 3 x 5 _0 direntangkan agar sesuai dengan bentuk larik A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5 9
Observation (1d array): 2 Codes (2d array): 4 x 2 Diff (2d array): 4 x 2
Gambar 5
Operasi dasar kuantisasi vektor menghitung jarak antara objek yang akan diklasifikasikan, kotak gelap, dan beberapa kode yang diketahui, lingkaran abu-abu. Dalam kasus sederhana ini, kode mewakili kelas individu. Kasus yang lebih kompleks menggunakan banyak kode per kelas
Biasanya, sejumlah besar A (2d array): 5 x 4 B (1d array): 1 Result (2d array): 5 x 4 A (2d array): 5 x 4 B (1d array): 4 Result (2d array): 5 x 4 A (3d array): 15 x 3 x 5 B (3d array): 15 x 1 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 1 Result (3d array): 15 x 3 x 5 _6, mungkin dibaca dari database, dibandingkan dengan sekumpulan A (4d array): 8 x 1 x 6 x 1 B (3d array): 7 x 1 x 5 Result (4d array): 8 x 7 x 6 x 5 9. Pertimbangkan skenario ini
>>> a = np.array([1.0, 2.0, 3.0]) >>> b = 2.0 >>> a * b array([2., 4., 6.]) _0
Array tiga dimensi, A (2d array): 5 x 4 B (1d array): 1 Result (2d array): 5 x 4 A (2d array): 5 x 4 B (1d array): 4 Result (2d array): 5 x 4 A (3d array): 15 x 3 x 5 B (3d array): 15 x 1 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 5 Result (3d array): 15 x 3 x 5 A (3d array): 15 x 3 x 5 B (2d array): 3 x 1 Result (3d array): 15 x 3 x 5 _8, adalah konsekuensi dari penyiaran, bukan keharusan untuk perhitungan. Kumpulan data besar akan menghasilkan larik menengah besar yang secara komputasi tidak efisien. Sebagai gantinya, jika setiap pengamatan dihitung secara individual menggunakan loop Python di sekitar kode dalam contoh dua dimensi di atas, array yang jauh lebih kecil digunakan
Broadcasting adalah alat yang ampuh untuk menulis kode pendek dan biasanya intuitif yang melakukan perhitungannya dengan sangat efisien di C. Namun, ada kasus ketika penyiaran menggunakan memori dalam jumlah besar yang tidak perlu untuk algoritme tertentu. Dalam kasus ini, lebih baik menulis loop luar algoritme dengan Python. Ini juga dapat menghasilkan kode yang lebih mudah dibaca, karena algoritme yang menggunakan penyiaran cenderung menjadi lebih sulit untuk ditafsirkan karena jumlah dimensi dalam siaran meningkat.
Catatan kaki
[]Dalam contoh ini, bobot lebih berdampak pada penghitungan jarak daripada tinggi karena nilai yang lebih besar. Dalam praktiknya, penting untuk menormalkan tinggi dan berat badan, seringkali dengan deviasi standarnya di seluruh kumpulan data, sehingga keduanya memiliki pengaruh yang sama pada perhitungan jarak.