Pada kuliah kali ini kita akan membahas berbagai cara penerapannya, tentang kelebihan dan kekurangannya. Saya ingin berbicara tentang tiga tipe utama penurunan gradien– penuh, batch dan stokastik.

Di sebagian besar kursus sebelumnya kami menggunakan penurunan gradien penuh.

Mengapa demikian?

Karena itu membawa lebih banyak manfaat, jika kita ingin memaksimalkan kemungkinan untuk seluruh rangkaian pelatihan:

Kekurangan dari pendekatan ini adalah penghitungan gradien membutuhkan waktu yang lama karena bergantung pada setiap contoh (pengamatan).

Kebalikannya adalah penurunan gradien stokastik. Itu bergantung pada kesalahan hanya untuk satu pengamatan tertentu:

Metode tersebut didasarkan pada kenyataan bahwa semua observasi bersifat independen dan berdistribusi seragam, sehingga dalam jangka panjang kesalahannya akan berkurang karena semua observasi diambil dari distribusi yang sama. Dalam hal ini, ketika perhitungan dikurangi dari N pengamatan ke 1, merupakan peningkatan luar biasa dalam metode ini.

Apa sisi buruknya?

Faktanya adalah jika dengan penurunan gradien penuh logaritma fungsi kemungkinan selalu meningkat pada setiap iterasi, maka dengan penurunan stokastik logaritma fungsi kemungkinan bahkan dapat memburuk. Faktanya, perilaku fungsi biaya akan berubah secara kacau pada setiap iterasi, namun dalam jangka panjang akan tetap menurun.

Kompromi yang baik antara kedua metode ini adalah penurunan gradien batch. Jika kita memiliki, misalnya, 10.000 observasi, maka kita dapat membaginya menjadi 100 batch yang masing-masing terdiri dari 100 observasi dan menghitung fungsi biaya berdasarkan setiap batch pada setiap iterasi:

Apa yang akan terjadi pada fungsi biaya dalam kasus ini?

Ini juga bisa menjadi lebih besar, tetapi tidak akan terlalu semrawut dibandingkan dengan penurunan gradien stokastik murni.

Dan saya ingin menggunakan kesempatan ini untuk mencatat bahwa jika Anda ingin menerima materi gratis terkait pembelajaran mendalam dan mesin, serta pemrosesan data, kunjungi situs web saya lazyprogrammer.me. Saya terus-menerus menulis konten baru tentang topik ini, jadi sering-seringlah memeriksanya kembali. Seharusnya ada permintaan untuk berlangganan, sehingga Anda dapat mendaftar untuk mendapatkan pengenalan gratis saya tentang ilmu data. Ia memiliki banyak sumber daya yang bagus untuk dijelajahi. bahasa piton, algoritme dan struktur data, serta kupon kursus.

Penurunan gradien penuh, batch, dan stokastik dalam kode

Sekarang mari kita bandingkan perubahan fungsi biaya dalam tiga kasus penurunan gradien - penuh, batch, dan stokastik. Karena contoh ini memiliki banyak kode yang disalin dari file lain, kita hanya akan menelusuri teks program satu per satu.

Jadi di awal file kita mengimpor semua perpustakaan biasa. Dari berkas util.py kami mengimpor fungsinya dapatkan_transformed_data untuk mengubah data menggunakan analisis komponen utama, serta fungsi maju, tanggal_kesalahan, biaya, gradW, gradb Dan indikator y2.

impor numpy sebagai np

impor panda sebagai pd

impor matplotlib.pyplot sebagai plt

dari sklearn.utils impor acak

dari tanggal waktu impor tanggal waktu

dari util import get_transformed_data, forward, error_rate, cost, gradW, gradb, y2indicator

Untuk mempercepat prosesnya, bukan sepenuhnya jaringan saraf kami menggunakan.

Jadi pertama-tama kita menggunakan fungsinya dapatkan_transformed_data, hanya mengambil 300 kolom pertama. Selanjutnya, kita normalkan X kita dengan mengurangkan mean dan membaginya dengan deviasi standar. Lalu, sejak fungsinya dapatkan_transformed_data telah mencampurkan data kami, kami meninggalkan 1.000 contoh terakhir sebagai set pengujian, menggunakan sisanya sebagai set pelatihan.

def utama():

X, Y, _, _ = get_transformed_data()

X = X[:, :300]

# normalkan X terlebih dahulu

mu = X.berarti( sumbu=0)

std = X.std( sumbu=0)

X = (X – mu) / std

print “Melakukan regresi logistik...”

Latihan X = X[:-1000,]

Ykereta = Y[:-1000]

Uji X = X[-1000:,]

N, D = Xtrain.bentuk

Ytrain_ind = y2indikator(Ytrain)

Ytest_ind = y2indikator(Ytest)

Kemudian kita memulai koefisien pembobotan dan suku dummy. Harap dicatat bahwa koefisien bobot yang dipicu ditetapkan relatif kecil - proporsional akar kuadrat dari dimensi. Bahkan sebelum merekam video ini, saya menetapkan koefisien pembelajaran dan penalti regularisasi masing-masing menjadi 0,0001 dan 0,01. Jumlah iterasinya akan kita atur menjadi 200 agar perhitungannya tidak memakan waktu terlalu lama.

#1.penuh

b = np.nol(10)

AKAN=

lr = 0,0001

reguler = 0,01

t0 = tanggalwaktu.sekarang()

untuk aku masuk rentang x(200):

p_y = maju(Xtrain, W, b)

Selanjutnya, kami memperbarui nilai dan istilah bebas menggunakan penurunan gradien dan . Kami juga menggunakan fungsinya maju untuk menghitung nilai fungsi biaya saat melewati set pelatihan. Nilai error rate akan kami tampilkan setiap sepuluh iterasi. Selain itu, kami akan menampilkan waktu yang dihabiskan untuk perhitungan, karena salah satu metode sangat cepat, dan metode lainnya sangat lambat.

W += lr*(lulusanW(Ytrain_ind, p_y, Xtrain) – reg*W)

b += lr*(gradb(Ytrain_ind, p_y) – reg*b)

LL.tambahkan(ll)

jika saya % 10 == 0:

cetak “Tingkat kesalahan:”, err

p_y = maju(uji X, W, b)

cetak “Waktu yang berlalu untuk GD penuh:”, datetime.now() – t0

Dalam kasus penurunan gradien stokastik, kita melakukan hal yang hampir sama, kecuali kita hanya membuat satu lintasan melalui data, karena dengan penurunan gradien stokastik kita hanya melihat satu contoh dan memperbarui bobot dan perpotongan secara terpisah pada setiap lintasan, lalu mengacak ulang data . Karena jika Anda melihat semua contoh, program akan bekerja sangat lambat, jadi kami akan membatasi diri hanya pada 500 contoh.

Kemudian, seperti biasa, kita menghitung gradien, memperbarui bobot menggunakan regularisasi, dan menghitung tingkat kesalahan, hanya saja kita hanya mencetak nilai koefisien setiap N/2 yang dilewati, karena pada jika tidak perhitungannya akan sangat panjang. Jika tidak, semuanya sama saja.

#2. stokastik

W = np.acak.randn(D, 10) / 28

b = np.nol(10)

LL_stokastik =

lr = 0,0001

reguler = 0,01

t0 = tanggalwaktu.sekarang()

untuk aku masuk rentang x(1): # membutuhkan waktu sangat lama karena kami menghitung biaya untuk 41 ribu sampel

untuk n masuk rentang x(min(N, 500)): # shortcut supaya tidak memakan waktu lama…

x = tmpX.bentuk ulang(1,D)

y = tmpY.bentuk ulang(1,10)

p_y = maju(x, W, b)

p_y_test = maju(Xtest, W, b)

ll = biaya(p_y_test, Ytest_ind)

LL_stochastic.append(ll)

jika n % (N/2) == 0:

err = error_rate(p_y_test, Ytest)

print “Biaya pada iterasi %d: %.6f” % (i, ll)

cetak “Tingkat kesalahan:”, err

p_y = maju(uji X, W, b)

cetak “Akhir tingkat kesalahan:”, tingkat_kesalahan(p_y, uji Y)

print “Waktu yang telah berlalu untuk SGD:”, datetime.now() – t0

Dengan penurunan gradien batch, sekali lagi, hampir semuanya sama. Misalkan setiap paket berisi 500 contoh, sehingga jumlah total paket akan sama dengan N dibagi dengan ukuran paket.

#3.kumpulan

W = np.acak.randn(D, 10) / 28

b = np.nol(10)

LL_batch =

lr = 0,0001

reguler = 0,01

kumpulan_sz = 500

n_batch = N/batch_sz

t0 = tanggalwaktu.sekarang()

untuk aku masuk rentang x(50):

tmpX, tmpY = acak(Xtrain, Ytrain_ind)

untuk j masuk rentang x(n_batch):

x = tmpX

kamu = tmpY

p_y = maju(x, W, b)

W += lr*(lulusanW(y, p_y, x) – reg*W)

b += lr*(gradb(y, p_y) – reg*b)

p_y_test = maju(Xtest, W, b)

ll = biaya(p_y_test, Ytest_ind)

LL_batch.append(ll)

jika j % (n_batch/2) ​​== 0:

err = error_rate(p_y_test, Ytest)

print “Biaya pada iterasi %d: %.6f” % (i, ll)

cetak “Tingkat kesalahan:”, err

p_y = maju(uji X, W, b)

cetak “Tingkat kesalahan akhir:”, error_rate(p_y, Ytest)

cetak “Waktu yang telah berlalu untuk batch GD:”, datetime.now() – t0

Dan pada akhirnya kami menampilkan semua data kami di layar.

x1 = np.linspace(0, 1, len(LL))

plt.plot(x1, LL, label=”penuh”)

x2 = np.linspace(0, 1, len(LL_stochastic))

plt.plot(x2, LL_stochastic, label=”stokastik”)

x3 = np.linspace(0, 1, len(LL_batch))

plt.plot(x3, LL_batch, label=”kumpulan”)

plt.legenda()

plt.tampilkan()

jika __nama__ == '__utama__':

Jadi, mari kita jalankan programnya.

Kita dapat melihat bahwa dalam kasus penurunan gradien stokastik, kesalahannya hampir tidak membaik. Ini berarti diperlukan lebih banyak iterasi untuk mencapai peningkatan dengan penurunan gradien stokastik. Penurunan gradien penuh, seperti yang bisa kita lihat, menyatu lebih cepat dibandingkan penurunan batch, namun juga bekerja lebih lambat.

Jika kita melihat evolusi fungsi biaya dalam skala yang lebih besar, kita dapat melihat bahwa dalam kasus penurunan gradien batch tidak terlalu mulus, tidak seperti penurunan gradien penuh yang fungsi biayanya berubah dengan lancar karena dalam hal ini fungsi biaya adalah selalu menurun. Dalam kasus penurunan gradien stokastik, perubahan fungsi biaya juga tidak mulus:

Tampilan Postingan: 588

SVM

Mendukung Mesin Vektor(SVM Bahasa Inggris, mesin vektor dukungan) - seperangkat algoritma pembelajaran terawasi serupa yang digunakan untuk masalah klasifikasi dan analisis regresi. Milik keluarga pengklasifikasi linier dan juga dapat dianggap sebagai kasus khusus regularisasi Tikhonov. Properti khusus mesin vektor pendukung adalah dengan terus mengurangi kesalahan klasifikasi empiris dan meningkatkan kesenjangan, sehingga metode ini juga dikenal sebagai metode pengklasifikasi kesenjangan maksimum.

Ide utama dari metode ini adalah untuk memindahkan vektor asli ke ruang berdimensi lebih tinggi dan mencari hyperplane pemisah dengan celah maksimum di ruang tersebut. Dua hyperplane paralel dibangun di kedua sisi hyperplane yang memisahkan kelas kita. Hyperplane pemisah akan menjadi hyperplane yang memaksimalkan jarak ke dua hyperplane paralel. Algoritme beroperasi dengan asumsi bahwa apa lebih banyak perbedaan atau jarak antara hyperplanes paralel ini, semakin kecil kesalahan rata-rata pengklasifikasinya.

Seringkali dalam algoritma pembelajaran mesin terdapat kebutuhan untuk mengklasifikasikan data. Setiap objek data direpresentasikan sebagai vektor (titik) dalam ruang berdimensi (urutan angka p). Masing-masing poin ini hanya dimiliki oleh salah satu dari dua kelas. Kami tertarik pada apakah kami dapat memisahkan titik-titik dengan dimensi hyperplane. Ini adalah kasus khas keterpisahan linier. Ada banyak hyperplane seperti itu. Oleh karena itu, wajar untuk percaya bahwa memaksimalkan kesenjangan antar kelas akan menghasilkan klasifikasi yang lebih percaya diri. Artinya, dapatkah kita menemukan hyperplane sedemikian rupa sehingga jaraknya ke titik terdekat adalah maksimum. Ini berarti jarak antara dua titik terdekat yang terletak sejajar sisi yang berbeda hyperplane, maksimal. Jika hyperplane seperti itu ada, maka hal itu akan sangat menarik perhatian kita; ini disebut hyperplane pemisah optimal, dan pengklasifikasi linier yang sesuai disebut pengklasifikasi pemisah optimal.

Secara formal, permasalahan tersebut dapat diuraikan sebagai berikut.

Kita asumsikan bahwa titik-titik tersebut berbentuk: , dimana bernilai 1 atau?1, bergantung pada kelas mana titik tersebut berada. Masing-masing adalah vektor real berdimensi, biasanya dinormalisasi dengan nilai atau. Jika titik-titik tersebut tidak dinormalisasi, maka titik dengan deviasi yang besar dari koordinat titik rata-rata akan terlalu mempengaruhi pengklasifikasi. Kita dapat menganggap ini sebagai kumpulan pelatihan yang setiap elemennya sudah diberi kelasnya. Kami ingin algoritma mesin vektor dukungan mengklasifikasikannya dengan cara yang sama. Untuk melakukan ini, kita membuat hyperplane pemisah, yang berbentuk:

Sebuah vektor tegak lurus terhadap hyperplane pemisah. Parameternya sama nilai absolutnya dengan jarak dari hyperplane ke titik asal. Jika parameternya nol, hyperplane melewati titik asal, yang membatasi solusi.

Karena kita tertarik pada pemisahan optimal, kita tertarik pada vektor tumpuan dan bidang hiper yang sejajar dengan vektor tumpuan optimal dan paling dekat dengan vektor tumpuan kedua kelas. Dapat ditunjukkan bahwa hyperplane paralel tersebut dapat dijelaskan dengan persamaan berikut (hingga normalisasi).

Jika set pelatihan dapat dipisahkan secara linier, maka kita dapat memilih hyperplanes sedemikian rupa sehingga tidak ada titik dalam set pelatihan yang terletak di antara keduanya dan kemudian memaksimalkan jarak antar hyperplanes. Lebar strip di antara mereka mudah ditemukan dari pertimbangan geometri, jadi tugas kita adalah meminimalkannya. Untuk mengecualikan semua titik dari strip, kita harus memastikan semua itu

Ini juga dapat ditulis sebagai:

Dalam kasus keterpisahan kelas secara linier, masalah membangun hyperplane pemisah yang optimal direduksi menjadi minimalisasi pada kondisi (1). Ini adalah masalah optimasi kuadrat yang berbentuk:

Menurut teorema Kuhn-Tucker, permasalahan ini setara dengan permasalahan ganda dalam mencari titik pelana fungsi Lagrange.

Dimana adalah vektor variabel ganda

Mari kita kurangi permasalahan ini menjadi permasalahan pemrograman kuadrat ekuivalen yang hanya berisi dua variabel:

Katakanlah kita telah memutuskan tugas ini, maka Anda dapat menemukannya menggunakan rumus:

Hasilnya, algoritma klasifikasi dapat ditulis sebagai:

Dalam hal ini, penjumlahan tidak dilakukan pada seluruh sampel, tetapi hanya pada vektor pendukungnya

Dalam kasus kelas yang tidak dapat dipisahkan secara linier, agar algoritme berfungsi, kami mengizinkannya membuat kesalahan pada set pelatihan. Mari kita perkenalkan sekumpulan variabel tambahan yang mengkarakterisasi besarnya kesalahan pada objek. Mari kita ambil itu titik awal(2), kami melunakkan batasan pertidaksamaan dan juga memasukkan penalti untuk kesalahan total ke dalam fungsi yang diminimalkan:

Koefisien adalah parameter pengaturan metode yang memungkinkan Anda menyesuaikan hubungan antara memaksimalkan lebar pita pemisah dan meminimalkan kesalahan total.

Demikian pula, dengan menggunakan teorema Kuhn-Tucker, kita mereduksi masalahnya menjadi mencari titik pelana dari fungsi Lagrange:

Dengan analogi, kami mengurangi masalah ini menjadi masalah yang setara:

Dalam praktiknya, untuk membangun mesin vektor pendukung, mereka memecahkan masalah ini dengan tepat, dan bukan (3), karena dalam kasus umum tidak mungkin untuk menjamin keterpisahan linier titik-titik menjadi dua kelas. Versi algoritme ini disebut algoritme SVM margin lunak, sedangkan dalam kasus yang dapat dipisahkan secara linier, mereka menyebutnya sebagai SVM margin keras.

Untuk algoritma klasifikasi, rumus (4) dipertahankan, dengan satu-satunya perbedaan bahwa sekarang tidak hanya objek referensi, tetapi juga objek penyusup memiliki nilai bukan nol. Dalam arti tertentu, hal ini merupakan suatu kerugian, karena pelakunya sering kali adalah emisi kebisingan, dan aturan yang menentukan berdasarkan hal tersebut, pada kenyataannya, didasarkan pada kebisingan.

Konstanta biasanya dipilih berdasarkan kriteria kontrol geser. Ini adalah metode yang memakan waktu, karena permasalahan harus diselesaikan lagi untuk setiap nilai.

Jika ada alasan untuk meyakini bahwa sampel hampir dapat dipisahkan secara linier, dan hanya objek outlier yang diklasifikasikan secara salah, maka pemfilteran outlier dapat diterapkan. Pertama, permasalahan diselesaikan untuk C tertentu, dan sebagian kecil objek dengan kesalahan terbesar dikeluarkan dari sampel. Setelah ini, masalahnya diselesaikan lagi dengan menggunakan sampel terpotong. Mungkin perlu melakukan beberapa iterasi hingga objek yang tersisa dapat dipisahkan secara linier.

Algoritme untuk membangun hyperplane pemisah yang optimal, diusulkan pada tahun 1963 oleh Vladimir Vapnik dan Alexei Chervonenkis, adalah algoritma klasifikasi linier. Namun, pada tahun 1992, Bernhard Boser, Isabelle Guyon dan Vapnik mengusulkan cara untuk membuat pengklasifikasi nonlinier berdasarkan transisi dari produk skalar ke kernel arbitrer, yang disebut trik kernel (pertama kali diusulkan oleh M.A. Aizerman, E.M. Bravermann dan L.V. . Rozonoer untuk metode fungsi potensial), yang memungkinkan konstruksi pemisah nonlinier. Algoritme yang dihasilkan sangat mirip dengan algoritma klasifikasi linier, dengan satu-satunya perbedaan adalah bahwa setiap perkalian titik dalam rumus di atas digantikan oleh fungsi kernel nonlinier (perkalian titik dalam ruang berdimensi lebih tinggi). Hyperplane pemisah yang optimal mungkin sudah ada di ruang ini. Karena dimensi ruang yang dihasilkan bisa lebih besar dari dimensi ruang aslinya, transformasi yang membandingkan hasil kali skalar akan menjadi nonlinier, yang berarti fungsi yang sesuai dengan hyperplane pemisah optimal pada ruang asal juga akan menjadi nonlinier.

Perlu dicatat bahwa jika ruang asli memiliki dimensi yang cukup tinggi, maka diharapkan sampel di dalamnya dapat dipisahkan secara linier.

Kernel yang paling umum:

1. Inti linier:

2. Polinomial (homogen):

3. Fungsi RBF:

4. Sigmoid:

Dalam kerangka tugas yang diberikan kepada kita, kita akan menggunakan inti homogen linier. Kernel ini menunjukkan hasil yang sangat baik dalam tugas-tugas Klasifikasi Dokumen, meskipun dibandingkan dengan Naive Bayes Classifier, pelatihan pengklasifikasi ini membutuhkan waktu yang relatif lama. Pengoperasian semua inti lainnya dari daftar ini dan ditemukan bahwa pelatihan mereka memakan waktu yang jauh lebih lama, tanpa membawa banyak peningkatan dalam akurasi klasifikasi.

Untuk mempercepat pelatihan, kita akan menggunakan metode yang disebut Stochastic Gradient Descent, yang memungkinkan kita mempercepat pelatihan pengklasifikasi secara signifikan tanpa mengorbankan banyak keakuratannya.

Penurunan Gradien Stokastik

Metode gradien adalah kelas algoritma optimasi yang luas yang digunakan tidak hanya di pembelajaran mesin. Di sini, pendekatan gradien akan dianggap sebagai cara untuk memilih vektor bobot sinaptik dalam pengklasifikasi linier. Biarkan ketergantungan target hanya diketahui pada objek set pelatihan:

Mari kita temukan algoritma yang mendekati ketergantungan. Dalam kasus pengklasifikasi linier algoritma yang diperlukan memiliki bentuk:

di mana memainkan peran fungsi aktivasi (dalam kasus paling sederhana yang dapat kita masukkan).

Menurut prinsip meminimalkan risiko empiris, cukup menyelesaikan masalah optimasi:

Dimana fungsi kerugian yang diberikan.

Untuk memperkecil, kami menerapkan metode penurunan gradien. Ini algoritma langkah demi langkah, pada setiap iterasi yang vektornya berubah ke arah penurunan fungsional terbesar (yaitu, ke arah antigradien):

Dimana parameter positifnya disebut learning rate.

Ada 2 pendekatan utama untuk menerapkan penurunan gradien:

1. Batch, ketika pada setiap iterasi sampel pelatihan dilihat secara keseluruhan, dan baru setelah itu diubah. Hal ini memerlukan biaya komputasi yang besar.

2. Stochastic (stochastic/online), ketika pada setiap iterasi algoritma hanya satu objek yang dipilih dari sampel pelatihan dengan cara tertentu (acak). Dengan demikian, vektornya disesuaikan dengan setiap objek yang baru dipilih.

Anda dapat merepresentasikan algoritma penurunan gradien stokastik dalam pseudocode sebagai berikut:

· - sampel pelatihan

· - kecepatan belajar

· - parameter pemulusan fungsional

1. Vektor bobot

1) Inisialisasi bobot

2) Inisialisasi evaluasi fungsional saat ini:

3) Ulangi:

1. Pilih objek dari secara acak

2. Hitung nilai keluaran algoritma dan kesalahannya:

3. Lakukan langkah penurunan gradien

4. Evaluasi nilai fungsionalitas:

4) Hingga nilainya stabil dan/atau bobotnya berhenti berubah.

Keuntungan utama SGD adalah kecepatannya mempelajari data yang terlalu besar. Hal inilah yang menarik bagi kami dalam rangka tugas yang diberikan kepada kami, karena volume data masukan akan sangat besar. Pada saat yang sama, algoritma SGD, berbeda dengan penurunan gradien batch klasik, memberikan akurasi klasifikasi yang sedikit lebih rendah. Selain itu, algoritme SGD tidak dapat diterapkan saat melatih mesin vektor dukungan dengan kernel nonlinier.

Kesimpulan

Sebagai bagian dari penyelesaian masalah, kita perlu menggunakan algoritma konversi data sumber TF-IDF, yang akan memungkinkan kita meningkatkan bobot peristiwa yang jarang terjadi dan mengurangi bobot peristiwa yang sering terjadi. Data yang diperoleh setelah transformasi akan kami transfer ke pengklasifikasi yang sesuai untuk menyelesaikan masalah yang kami hadapi, yaitu: Naive Bayes Classifier atau Support Vector Machine dengan Kernel Linier, dilatih menggunakan metode penurunan gradien stokastik. Kami juga akan menguji efektivitas Mesin Vektor Dukungan dengan kernel nonlinier yang dilatih menggunakan metode penurunan gradien batch. Namun, tipe ini pengklasifikasi tampaknya tidak cocok untuk tugas tersebut karena kernel yang terlalu kompleks dan kecenderungan overfit, yang mana pengklasifikasi berkinerja buruk pada data yang tidak digunakan untuk melatih pengklasifikasi.

data pemrosesan awal mesin perangkat lunak

Gradien stokastik diperkirakan dengan rumus:

yaitu, jumlah semua vektor acak dengan bobot sama dengan pertambahan fungsi yang diminimalkan dalam arah acak tertentu.

Jika kita mengambil vektor satuan sebagai parameter, maka perkiraan ini, seperti yang mudah dilihat dari (3.3.22), memberikan nilai gradien yang tepat.

Kedua estimasi gradien yang dijelaskan dapat digunakan secara efektif untuk nilai apa pun, termasuk dan yang secara signifikan membedakannya dari metode estimasi deterministik (3.3.22), yang keadaan yang sama menegaskan bahwa metode deterministik digeneralisasikan ke metode acak (lihat bagian akhir ayat 3.3.1 ). Mari kita berikan contoh lain dari generalisasi tersebut.

Pencarian gradien (3.3.21) adalah kasus khusus menurut setidaknya dua algoritma pencarian acak. Algoritma pertama:

dimana masih merupakan vektor berdimensi acak satuan. Ini adalah algoritma pencarian acak gradien yang terkenal. Algoritma kedua berbentuk (3.3.23), namun estimasi gradien dihitung menggunakan rumus

Seperti yang mudah dilihat, kedua algoritma berubah menjadi algoritma pencarian gradien (3.3.21).

Dengan demikian, pencarian acak adalah perpanjangan alami, kelanjutan dan generalisasi dari metode pencarian reguler yang diketahui.

Fitur pencarian acak lainnya yang terbuka peluang yang luas untuk penggunaannya yang efektif, adalah dengan menggunakan operator langkah acak sebagai model stokastik dari operator reguler yang kompleks untuk menemukan arah pencarian dalam ruang parameter yang dioptimalkan

Jadi, algoritma pencarian acak dengan taktik linier (3.3.12) adalah model stokastik algoritma penurunan paling curam:

di mana estimasi gradien model vektor acak. Sangat mengherankan bahwa “perkiraan” seperti itu bahkan tidak dapat disebut kasar, karena sifat stokastiknya tidak menyerupai sifat perkiraan gradien. Namun, seperti yang ditunjukkan di atas, algoritma pencarian acak tidak hanya efisien, tetapi dalam beberapa kasus lebih efisien daripada algoritma keturunan paling curam. Di Sini

operator langkah acak menggantikan operator estimasi gradien yang rumit, misalnya, menurut rumus (3.3.22).

Fitur pencarian acak berikutnya yang membedakannya dari metode biasa adalah globalitasnya, yang memanifestasikan dirinya terutama dalam algoritma pencarian acak lokal yang tidak dimaksudkan untuk menemukan ekstrem global. Jadi, algoritma keturunan acak dapat menemukan ekstrem global, tetapi algoritma keturunan paling curam biasa, pada prinsipnya, tidak mengizinkan kemungkinan ini, karena dirancang untuk menemukan ekstrem lokal.

Akibatnya, globalitas algoritma pencarian acak seperti “premium” untuk penggunaan keacakan dan sesuatu seperti “ aplikasi gratis» ke algoritma. Keadaan ini sangat penting ketika mengoptimalkan objek dengan struktur yang tidak diketahui, ketika tidak ada keyakinan penuh pada sifat masalah yang ekstrem tunggal dan adanya beberapa ekstrem mungkin terjadi (walaupun tidak diharapkan). Menggunakan metode dalam hal ini pencarian global itu merupakan pemborosan yang tidak bijaksana. Metode pencarian acak lokal adalah yang paling tepat di sini, karena metode ini secara efektif memecahkan masalah lokal dan, pada prinsipnya, dapat menyelesaikan masalah global, jika hal tersebut terjadi. Ini memberikan pencarian acak dengan semacam keandalan psikologis yang sangat dihargai oleh pengguna.

Kesederhanaan algoritmik pencarian acak menjadikannya menarik terutama bagi konsumen. Pengalaman menunjukkan hal itu algoritma yang diketahui pencarian acak hanyalah sebuah "kanvas" di mana pengguna, dalam setiap kasus tertentu, "menyulam pola" algoritma baru yang tidak hanya mencerminkan selera dan kecenderungannya (yang tidak dapat diabaikan), tetapi juga spesifikasi objek yang dioptimalkan. Yang terakhir ini menciptakan dasar yang baik untuk penerapan prinsip terkenal bahwa algoritma harus dirancang “untuk objek.” Terakhir, kesederhanaan algoritmik pencarian acak menentukan kesederhanaan implementasi perangkat kerasnya. Hal ini tidak hanya memungkinkan pembuatan pengoptimal yang sederhana, ringkas, dan andal dengan jumlah parameter optimal yang tidak terbatas, tetapi juga membuatnya cukup mudah untuk mengatur sintesis optimalnya di komputer.