Perkalian Skalar untuk AI: Memperbesar, Memperkecil, atau Membalik Vektor

Vektor arah dapat menunjukkan ke mana pembaruan model harus bergerak tanpa menunjukkan seberapa besar perpindahannya. Satu angka memasok keputusan kedua itu. Jika arahnya $[4,-3]^\mathsf{T}$, mengalikannya dengan $0.25$ menghasilkan perpindahan yang lebih pendek, $[1,-0.75]^\mathsf{T}$. Mengalikannya dengan $-1$ mempertahankan panjangnya, tetapi mengarahkannya ke sisi sebaliknya.

Angka itu adalah skalar: satu nilai yang diterapkan pada setiap koordinat. Setelah menyelesaikan pelajaran ini, Anda akan mampu menghitung hasil kali skalar–vektor, memprediksi arah dan magnitudonya dari tanda serta nilai mutlak skalar, mengimplementasikannya dengan benar di NumPy, dan mengenali mekanisme yang sama dalam pembaruan berskala laju pembelajaran atau kontribusi embedding berbobot.

Hasil pembelajaran: Skalakan sebuah vektor dan prediksi perubahan arah serta magnitudonya.

Pelajaran 15: Penjumlahan Vektor untuk AI menjelaskan bahwa vektor digabungkan dengan menjumlahkan koordinat yang bersesuaian. Perkalian skalar menyiapkan salah satu vektor itu sebelum penjumlahan: operasi ini mengendalikan seberapa kuat kontribusi vektor tersebut. Situs pendamping resmi Mathematics for Machine Learning memperkenalkan perkalian dengan skalar dalam Bagian 2.2 buku tersebut. Contoh, kode, sinar interaktif, aplikasi AI, dan asesmen di bawah ini adalah karya orisinal.

Satu angka menjangkau setiap koordinat

Misalkan $\boldsymbol{v}\in\mathbb{R}^{n}$ adalah vektor real dengan koordinat $v_1,v_2,\ldots,v_n$, dan $\alpha\in\mathbb{R}$ adalah skalar real. Huruf Yunani $\alpha$ (alpha) hanyalah nama untuk satu angka; simbol seperti $c$, $s$, atau $\lambda$ dapat menjalankan peran yang sama.

Operasi ini mempertahankan dimensi dan urutan koordinat vektor. Skalar tidak menambahkan koordinat, memilih satu koordinat, atau mencampur koordinat yang berdekatan. Skalar mengubah semua $n$ nilai melalui aturan perkalian yang sama.

Skala negatif membalik setiap koordinat tak nol

Ambil vektor pembaruan

dan pilih $\alpha=-1.5$. Simbol $\boldsymbol{u}$ menamai keseluruhan pembaruan tiga koordinat. Gunakan definisinya, bukan mencoba menebak jawaban hanya dari tanda minus.

Perhitungan ini memisahkan dua efek. Nilai mutlak—jarak skalar dari nol—adalah $|\alpha|=1.5$, sehingga ukuran vektor menjadi 1,5 kali ukuran semula. Tanda negatif membalik arahnya. Tidak satu pun dari kedua efek ini mengubah fitur atau parameter yang direpresentasikan oleh setiap koordinat.

Tanda memilih sinar; nilai mutlak memilih jangkauan

Dalam dua dimensi, gambarkan $\boldsymbol{v}$ sebagai panah dari titik asal. Setiap kelipatan skalar tak nol berada pada garis tak berhingga yang sama melalui panah tersebut. Skalar positif berada pada sinar yang sama, skalar negatif pada sinar berlawanan, dan nol meruntuhkan panah ke titik asal.

Dalam pelajaran ini, magnitudo berarti panjang panah Euclidean. Untuk $\boldsymbol{v}=[v_1,\ldots,v_n]^\mathsf{T}$, definisikan

Subskrip 2 membedakan aturan panjang ini dari aturan magnitudo lain yang akan dibahas di pelajaran berikutnya. Perkalian skalar mengubah magnitudo ini dengan faktor $|\alpha|$, bukan $\alpha$:

Nilai mutlak penting karena magnitudo tidak boleh negatif. Tanda berkaitan dengan arah; nilai mutlak berkaitan dengan ukuran.

Seret skalar di bawah melalui ketujuh kasus. Vektor tetapnya adalah $\boldsymbol{v}=[4,-3]^\mathsf{T}$, dengan magnitudo $5$. Panah berskala, kalimat status, dan tabel semuanya dimulai dari keadaan yang dirender server, $\alpha=1.5$, lalu diperbarui bersama setelah komponen terlihat.

Gambar ini hanya dua dimensi, tetapi aturannya tidak demikian. Dalam embedding dengan 768 koordinat, satu skalar tetap mengalikan seluruh 768 koordinat, dan magnitudo tetap berubah sebesar $|\alpha|$ menurut aturan panjang Euclidean.

Menskalakan sebelum menjumlahkan mengendalikan sebuah kontribusi

Perkalian skalar sangat berguna di samping penjumlahan vektor. Misalkan model memiliki keadaan konteks

dan kontribusi embedding kandidat

Dengan bobot $\alpha=0.5$, skalakan dahulu lalu jumlahkan:

Bobot mengubah seberapa kuat $\boldsymbol{e}$ berkontribusi pada jumlah ini. Bobot $0$ menghapus kontribusi tersebut; bobot negatif berkontribusi ke arah berlawanan. Inilah makna aritmetika yang tepat dari “kekuatan embedding”. Hal ini tidak menjamin keluaran jaringan saraf lengkap akan berubah sebanding langsung dengan $\alpha$: transformasi, normalisasi, dan operasi nonlinier berikutnya dapat mengubah efek hilirnya.

Aturan distributif menjelaskan mengapa penskalaan sinyal gabungan dapat dihitung sebelum atau sesudah bagian-bagiannya dijumlahkan:

Pada koordinat $j$, kedua sisi sama-sama bernilai $\alpha(v_j+w_j)=\alpha v_j+\alpha w_j$. Karena setiap koordinat sama, kedua vektor tersebut sama. Aturan pendamping $(\alpha+\beta)\boldsymbol{v}=\alpha\boldsymbol{v}+\beta\boldsymbol{v}$ akan membantu menggabungkan beberapa vektor berbobot secara efisien di pelajaran berikutnya.

Laju pembelajaran menskalakan arah yang diusulkan optimizer

Pertimbangkan langkah stochastic gradient descent (SGD) paling sederhana, tanpa momentum atau weight decay. Misalkan $\boldsymbol{\theta}$ adalah vektor parameter dan $\boldsymbol{g}$ adalah vektor gradien yang menunjuk ke arah kenaikan loss. Laju pembelajaran positif $\eta$ menskalakan arah sebelum pengurangan:

Kalkulus yang diperlukan untuk menghitung $\boldsymbol{g}$ akan muncul nanti dalam kursus; untuk saat ini, anggap ia sebagai vektor yang sudah diberikan dan periksa skalanya secara langsung.

Ini adalah perkalian skalar yang diikuti penjumlahan vektor $\boldsymbol{\theta}+(-\eta\boldsymbol{g})$. Dokumentasi PyTorch SGD saat ini menyatakan langkah parameter akhirnya dalam bentuk ini, setelah modifikasi apa pun pada arah pembaruan akibat weight decay, momentum, atau Nesterov yang dikonfigurasi. Klaim yang sempit ini penting: bila opsi tersebut diaktifkan, laju pembelajaran dapat menskalakan arah yang sudah dimodifikasi, bukan gradien mentah yang belum disentuh.

Untuk langkah numerik kecil, misalkan

Maka

Mengganti $\eta=0.25$ dengan $\eta=0.5$ akan menggandakan magnitudo pembaruan yang diusulkan kali ini, sambil mempertahankan arahnya. Fakta aritmetika itu sendiri tidak mengatakan apakah laju pembelajaran yang lebih besar akan memperbaiki pelatihan atau tetap stabil; pertanyaan tersebut bergantung pada permukaan loss dan perilaku optimizer, dan termasuk dalam modul optimasi berikutnya.

NumPy mengalikan array; list Python mengulang

multiply milik NumPy mengalikan argumen secara elementwise, dan * adalah singkatan operatornya untuk array. Aturan broadcasting NumPy memungkinkan satu skalar berlaku pada array tanpa membuat array penuh berisi skalar yang diulang.

import numpy as np

vector = np.array([4.0, -3.0, 2.0])
alpha = -1.5

scaled_with_operator = alpha * vector
scaled_with_function = np.multiply(alpha, vector)

print("vector shape:", vector.shape)
print("operator result:", scaled_with_operator)
print("function result:", scaled_with_function)
print("same values:", np.array_equal(
    scaled_with_operator, scaled_with_function
))

Output yang telah diverifikasi adalah

vector shape: (3,)
operator result: [-6.   4.5 -3. ]
function result: [-6.   4.5 -3. ]
same values: True

List Python biasa mengubah makna *. Dokumentasi sequence Python mendefinisikan perkalian dengan bilangan bulat sebagai pengulangan:

coordinates = [4.0, -3.0, 2.0]

print(2 * coordinates)
print(2 * np.array(coordinates))

[4.0, -3.0, 2.0, 4.0, -3.0, 2.0]
[ 8. -6.  4.]

Hasil pertama memiliki enam entri dan bukan $2\boldsymbol{v}$. Konversikan koordinat numerik menjadi array NumPy sebelum memakai aritmetika array. Nilai non-integer seperti 0.5 * coordinates menimbulkan TypeError, bukan menskalakan entri.

Skalar kini memiliki dua tugas: tandanya memilih apakah vektor tak nol mempertahankan atau membalik arah, sedangkan nilai mutlaknya mengendalikan magnitudo. Setelah beberapa vektor berskala seperti itu dijumlahkan, perkalian skalar dan penjumlahan vektor menjadi kombinasi linear—konstruksi yang akan digunakan pada pelajaran berikutnya.

Uji pemahaman

3 * [1, -2]
# [1, -2, 1, -2, 1, -2]

import numpy as np

3 * np.array([1, -2])
# array([ 3, -6])