di mana f i – fungsi yang dikira pada kelompok ke-i, i dipilih secara rawak;

Langkah pembelajaran ialah hiperparameter; jika nilai terlalu besar, algoritma pembelajaran akan menyimpang; jika nilai terlalu kecil, ia akan menumpu secara perlahan.

Penurunan kecerunan stokastik dengan inersia

Dalam kaedah penurunan kecerunan stokastik, ia adalah perkara biasa untuk kecerunan berubah secara besar-besaran pada setiap lelaran. Ini disebabkan oleh fakta bahawa kefungsian dikira pada pelbagai data, yang mungkin berbeza dengan ketara. Perubahan ini boleh diselaraskan dengan menggunakan kecerunan yang dikira dalam lelaran sebelumnya dan diskalakan oleh hiperparameter inersia μ:

	(14)
	(15)

Seperti yang anda mungkin rasa, hiperparameter inersia μ mempunyai nama ini kerana fakta bahawa, seperti yang dipanggil daya inersia Newtonian, i.e. daya balas, "menentang" perubahan dalam kecerunan dan mengurangkan perubahan dalam pekali pemberat sepanjang latihan. Algoritma pembelajaran ini dipanggil stochastic gradient descent with momentum atau SGDM (stochastic gradient descent with momentum).

Kaedah Kecerunan Suai

Kaedah kecerunan penyesuaian (Adagrad - dari bahasa Inggeris "algoritma kecerunan penyesuaian") adalah berdasarkan idea penskalaan. Ia menskala semula kadar pembelajaran untuk setiap parameter boleh tala secara individu, sambil mengambil kira sejarah semua kecerunan masa lalu untuk parameter tersebut. Untuk melakukan ini, setiap unsur kecerunan dibahagikan dengan punca kuasa dua hasil tambah kuasa dua unsur kecerunan sepadan sebelumnya. Pendekatan ini secara berkesan mengurangkan kadar pembelajaran untuk pemberat yang mempunyai nilai kecerunan yang besar, dan juga mengurangkan kadar pembelajaran untuk semua parameter dari semasa ke semasa, kerana jumlah kuasa dua secara berterusan meningkat untuk semua parameter dengan setiap lelaran. Apabila menetapkan parameter penskalaan awal sifar g = 0, formula untuk mengira semula pekali pemberat mempunyai bentuk (pembahagian dilakukan elemen demi elemen).

Kecerunan stokastik dianggarkan dengan formula:

iaitu, ia adalah jumlah semua vektor rawak dengan pemberat sama dengan kenaikan fungsi yang diminimumkan dalam arah rawak yang diberikan.

Jika kita mengambil vektor unit sebagai parameter, maka anggaran ini, seperti yang boleh dilihat dengan mudah daripada (3.3.22), memberikan nilai tepat kecerunan.

Kedua-dua anggaran kecerunan yang diterangkan boleh digunakan dengan berkesan untuk sebarang nilai, termasuk dan yang membezakannya dengan ketara daripada kaedah anggaran deterministik (3.3.22), yang dengan tegasnya. Keadaan yang sama mengesahkan bahawa kaedah deterministik digeneralisasikan kepada yang rawak (lihat penghujung subseksyen 3.3.1). Mari kita berikan satu lagi contoh generalisasi sedemikian.

Carian kecerunan (3.3.21) ialah kes khas sekurang-kurangnya dua algoritma carian rawak. Algoritma pertama:

di mana masih vektor rawak unit -dimensi. Ini ialah algoritma carian rawak kecerunan yang terkenal. Algoritma kedua mempunyai bentuk (3.3.23), tetapi anggaran kecerunan dikira menggunakan formula

Apabila, seperti yang mudah dilihat, kedua-dua algoritma merosot menjadi algoritma carian kecerunan (3.3.21).

Oleh itu, carian rawak adalah lanjutan semula jadi, kesinambungan dan generalisasi kaedah carian biasa yang diketahui.

Satu lagi ciri carian rawak, yang membuka kemungkinan luas untuk penggunaannya yang berkesan, ialah penggunaan operator langkah rawak sebagai model stokastik operator biasa yang kompleks untuk mencari arah carian dalam ruang parameter yang dioptimumkan

Oleh itu, algoritma carian rawak dengan taktik linear (3.3.12) ialah model stokastik bagi algoritma penurunan paling curam:

di mana vektor rawak memodelkan anggaran kecerunan. Adalah aneh bahawa "anggaran" sedemikian tidak boleh dipanggil kasar, kerana sifat stokastiknya tidak menyerupai sifat kecerunan yang dianggarkan. Walau bagaimanapun, seperti yang ditunjukkan di atas, algoritma carian rawak bukan sahaja cekap, tetapi dalam beberapa kes ia lebih cekap daripada algoritma turunan paling curam. Di sini

pengendali langkah rawak menggantikan operator anggaran kecerunan yang rumit, contohnya, mengikut formula (3.3.22).

Ciri carian rawak seterusnya yang membezakannya dengan baik daripada kaedah biasa ialah globalitinya, yang memanifestasikan dirinya terutamanya dalam algoritma carian rawak tempatan yang tidak bertujuan untuk mencari ekstrem global. Oleh itu, algoritma keturunan rawak boleh mencari ekstrem global, tetapi algoritma keturunan tercuram biasa, pada dasarnya, tidak membenarkan kemungkinan ini, kerana ia direka untuk mencari ekstrem tempatan.

Akibatnya, sifat global algoritma carian rawak ialah sejenis "premium" untuk penggunaan rawak dan sesuatu seperti "aplikasi percuma" kepada algoritma. Keadaan ini amat penting apabila mengoptimumkan objek dengan struktur yang tidak diketahui, apabila tidak ada keyakinan sepenuhnya terhadap sifat satu-ekstrem masalah dan kehadiran beberapa ekstrem adalah mungkin (walaupun tidak dijangka). Menggunakan kaedah carian global dalam kes ini akan menjadi pembaziran yang tidak munasabah. Kaedah carian rawak tempatan adalah yang paling sesuai di sini, kerana ia berkesan menyelesaikan masalah tempatan dan boleh, pada dasarnya, menyelesaikan masalah global, jika ia berlaku. Ini menyediakan carian rawak dengan sejenis kebolehpercayaan psikologi yang sangat dihargai oleh pengguna.

Kesederhanaan algoritma carian rawak menjadikannya menarik terutamanya kepada pengguna. Pengalaman menunjukkan bahawa algoritma carian rawak yang diketahui hanyalah "kanvas" di mana pengguna, dalam setiap kes tertentu, "menyulam corak" algoritma baharu yang mencerminkan bukan sahaja citarasa dan kecenderungannya (yang tidak boleh diabaikan), tetapi juga ciri khusus. daripada objek yang dioptimumkan. Yang terakhir mencipta asas yang menggalakkan untuk pelaksanaan prinsip terkenal bahawa algoritma harus direka "untuk objek." Akhir sekali, kesederhanaan algoritma carian rawak menentukan kesederhanaan pelaksanaan perkakasannya. Ini bukan sahaja memungkinkan untuk membina pengoptimum yang ringkas, padat dan boleh dipercayai dengan bilangan parameter yang dioptimumkan tanpa had, tetapi juga menjadikannya agak mudah untuk mengatur sintesis optimumnya pada komputer.

Hantar kerja baik anda di pangkalan pengetahuan adalah mudah. Gunakan borang di bawah

Pelajar, pelajar siswazah, saintis muda yang menggunakan pangkalan pengetahuan dalam pengajian dan kerja mereka akan sangat berterima kasih kepada anda.

Disiarkan pada http://www.allbest.ru/

Kementerian Pendidikan dan Sains Persekutuan Rusia

Institusi Pendidikan Autonomi Negeri Persekutuan

Pendidikan tinggi

"KAZAN (VOLGA) UNIVERSITI PERSEKUTUAN"

SEKOLAH MENENGAH TEKNOLOGI MAKLUMAT DAN SISTEM MAKLUMAT

KERJA KURSUS

Penurunan kecerunan stokastik. Pilihan pelaksanaan

pengenalan

Penurunan kecerunan ialah kaedah mencari ekstrem tempatan (minimum atau maksimum) fungsi dengan bergerak mengikut kecerunan.

Daripada semua kaedah pengoptimuman tempatan, ia adalah yang paling mudah untuk dilaksanakan. Ia mempunyai keadaan penumpuan yang agak lemah, tetapi kadar penumpuan agak rendah.

Keturunan kecerunan ialah algoritma popular untuk pelbagai model pembelajaran mesin, termasuk mesin vektor sokongan, regresi logistik dan model grafik. Digabungkan dengan algoritma perambatan belakang, ia adalah algoritma standard untuk melatih rangkaian saraf tiruan. Penurunan kecerunan stokastik bersaing dengan algoritma L-BFGS, yang juga digunakan secara meluas. Penurunan kecerunan stokastik telah digunakan sejak sekurang-kurangnya 1960 untuk melatih model regresi linear, pada mulanya di bawah nama Adaline.

Tujuan kerja kursus ini adalah untuk mempertimbangkan pelaksanaan beberapa pilihan untuk penurunan kecerunan stokastik, perbandingan seterusnya, dan penjelasan tentang kelebihan dan kekurangan.

1. Penurunan kecerunan stokastik

Penurunan kecerunan stokastik ialah algoritma pengoptimuman dan sering digunakan untuk menala parameter model pembelajaran mesin.

Keturunan kecerunan piawai menggunakan kecerunan untuk menukar parameter model. Kecerunan biasanya dikira sebagai jumlah kecerunan yang disebabkan oleh setiap elemen latihan. Vektor parameter berubah dalam arah antigradien dengan langkah tertentu. Oleh itu, keturunan kecerunan piawai memerlukan satu laluan melalui data latihan sebelum ia boleh menukar parameter.

Dalam penurunan kecerunan stokastik, nilai kecerunan dianggarkan oleh kecerunan fungsi kos yang dikira pada hanya satu elemen latihan. Parameter kemudian ditukar mengikut perkadaran kecerunan anggaran. Oleh itu, parameter model diubah selepas setiap objek pembelajaran. Untuk set data yang besar, keturunan kecerunan stokastik boleh memberikan kelebihan kelajuan yang ketara berbanding keturunan kecerunan standard.

Terdapat kompromi antara kedua-dua jenis keturunan kecerunan ini, kadangkala dipanggil "mini-batch". Dalam kes ini, kecerunan dianggarkan dengan jumlah untuk sebilangan kecil sampel latihan.

1.1 Prasyarat

Anggaran statistik dan pembelajaran mesin mempertimbangkan masalah meminimumkan fungsi, yang mempunyai bentuk:

di mana parameter yang meminimumkan mesti dianggarkan. Setiap istilah biasanya dikaitkan dengan pemerhatian ke-i dalam set data (digunakan untuk latihan).

Dalam statistik klasik, masalah meminimumkan jumlah timbul dalam kaedah kuasa dua terkecil, serta dalam kaedah kemungkinan maksimum (untuk pemerhatian bebas). Kelas umum penganggar yang terhasil daripada jumlah meminimumkan dipanggil penganggar-M. Walau bagaimanapun, dalam statistik, telah lama diakui bahawa keperluan untuk meminimumkan tempatan adalah terlalu terhad untuk beberapa masalah anggaran kemungkinan maksimum. Oleh itu, ahli teori statistik moden sering mempertimbangkan titik pegun pada fungsi kemungkinan (sifar bagi derivatif, fungsi anggaran, dan persamaan anggaran lain).

Masalah meminimumkan jumlah juga timbul dalam meminimumkan risiko empirikal. Dalam kes ini, ini ialah nilai fungsi kerugian untuk set-i, dan risiko empirikal.

Apabila meminimumkan fungsi, keturunan kecerunan piawai (atau "kelompok") akan melakukan lelaran berikut:

di manakah saiz langkah (kadangkala dipanggil kadar pembelajaran dalam pembelajaran mesin).

Dalam banyak kes, fungsi tambah mempunyai model ringkas yang melibatkan pengiraan mudah bagi fungsi jumlah dan hasil tambah kecerunan. Sebagai contoh, dalam statistik, keluarga eksponen dengan satu parameter membenarkan pengiraan ekonomi bagi fungsi dan kecerunan.

Walau bagaimanapun, dalam kes lain, jumlah anggaran kecerunan mungkin memerlukan anggaran mahal kecerunan daripada semua fungsi istilah. Apabila set latihan adalah besar dan tiada formula mudah wujud, menganggarkan jumlah kecerunan menjadi sangat mahal kerana menganggarkan kecerunan memerlukan menganggar semua kecerunan fungsi mengikut jumlah. Untuk menjimatkan kos pengiraan pada setiap lelaran, dalam penurunan kecerunan stokastik sampel ialah subset fungsi istilah pada setiap langkah. Ini sangat berkesan sekiranya masalah pembelajaran mesin berskala besar.

1.2 Kaedah berulang

Dalam keturunan kecerunan stokastik, kecerunan sebenar dianggarkan oleh kecerunan dalam contoh ini:

Apabila algoritma bergegas melalui set latihan, ia melaksanakan kemas kini di atas untuk setiap contoh latihan. Beberapa hantaran boleh dibuat ke atas set latihan sehingga algoritma menumpu. Data boleh dikocok untuk setiap pas untuk mengelakkan gelung. Pelaksanaan biasa mungkin menggunakan kadar pembelajaran adaptif supaya algoritma menumpu.

Dalam pseudokod, keturunan kecerunan stokastik boleh diwakili seperti berikut:

1) Pilih vektor parameter awal dan kadar pembelajaran.

2) Ulang sehingga minimum diperolehi:

2.1) Kocok secara rawak contoh dalam set latihan.

2.2) Untuk i = 1,2,...,n, lakukan:

Konvergensi keturunan kecerunan stokastik dianalisis menggunakan teori pengecilan cembung dan penghampiran stokastik. Apabila kadar pembelajaran mereput pada kadar yang sesuai, dan di bawah andaian yang agak lemah, keturunan kecerunan stokastik menumpu kepada minimum global apabila fungsi itu cembung atau pseudoconvex, dan sebaliknya menumpu kepada minimum tempatan.

1.3 Pilihan pelaksanaan

Banyak penambahbaikan telah dicadangkan dan digunakan ke atas kaedah penurunan kecerunan stokastik asas. Khususnya dalam pembelajaran mesin, keperluan untuk menetapkan kadar pembelajaran (saiz langkah) didapati bermasalah.

Jika anda menetapkan parameter ini terlalu besar, ia boleh menyebabkan algoritma menyimpang. Jika sebaliknya, algoritma akan menumpu secara perlahan.

Lanjutan dari segi konsep mudah bagi keturunan kecerunan stokastik menjadikan kadar pembelajaran sebagai fungsi menurun bergantung pada bilangan lelaran m.

Setelah melakukan operasi ini, adalah jelas bahawa lelaran pertama menyebabkan perubahan besar dalam parameter, manakala yang terkemudian hanya membuat penalaan halus.

Dalam rangka kerja ini, pilihan berikut untuk melaksanakan penurunan kecerunan stokastik akan dipertimbangkan:

1. 4 Momentum

Momentum, juga dikenali sebagai kaedah momentum, berasal dari ahli psikologi Amerika David Ramelhart, serta hasil kajian Geoffrey Hinton dan Ronald J William tentang kaedah perambatan belakang. Penurunan kecerunan stokastik dengan momentum mengingati kemas kini pada setiap lelaran dan menentukan kemas kini seterusnya sebagai gabungan linear kecerunan dan kemas kini sebelumnya:

Itu membawa kepada:

di mana parameter yang meminimumkan mesti dianggarkan dan saiz langkah (kadangkala dipanggil kadar pembelajaran dalam pembelajaran mesin).

Nama impuls berasal daripada analogi dengan impuls dalam fizik: vektor berat. Idea bahawa pergerakan titik bahan melalui ruang parameter memerlukan pecutan disebabkan oleh daya, yang merupakan kecerunan kehilangan.

Tidak seperti kaedah penurunan kecerunan stokastik klasik, ia cenderung mengekalkan pergerakan dalam satu arah, menghalang ayunan. Momentum telah digunakan dengan jayanya selama beberapa dekad.

1.5 AdaGrad

AdaGrad ialah turunan kecerunan stokastik yang diubah suai dengan pra-parameter kadar pembelajaran. Pertama kali diterbitkan pada 2011. Secara tidak formal, ia meningkatkan kadar pembelajaran untuk parameter yang lebih jarang dan mengurangkan kadar pembelajaran untuk yang kurang jarang. Strategi ini selalunya meningkatkan kemungkinan penumpuan berbanding dengan algoritma penurunan kecerunan stokastik standard di tempat di mana data jarang dan parameter jarang lebih bermaklumat.

Contoh aplikasi sedemikian termasuk pemprosesan bahasa semula jadi dan pengecaman corak.

Ia masih mempunyai asas kadar pembelajaran, tetapi didarab dengan unsur vektor yang merupakan pepenjuru hasil darab tensor matriks.

di manakah kecerunan pada lelaran m.

Diagonal ditentukan sebagai:

Vektor dikemas kini selepas setiap lelaran. Formula kemas kini kini kelihatan seperti ini:

atau ditulis sebagai kemas kini parameter awal,

Setiap satu meningkatkan kebolehskalaan faktor kadar pembelajaran yang digunakan pada satu parameter.

Oleh kerana penyebutnya ialah norma Euclidean bagi derivatif sebelumnya, nilai marginal parameter kemas kini dikekang, manakala parameter yang mempunyai kemas kini kecil menerima tahap pembelajaran yang lebih tinggi.

Semasa kerja sedang dilakukan pada masalah pengoptimuman cembung, AdaGrad telah berjaya digunakan untuk masalah pengoptimuman bukan cembung.

1.6 RMSProp

RMSProp juga merupakan kaedah di mana kadar pembelajaran disesuaikan untuk setiap parameter. Idea ini adalah untuk membahagikan kadar pembelajaran untuk berat tertentu dengan purata bergerak kecerunan terkini untuk berat tersebut. Oleh itu, purata bergerak pertama dikira sebagai segi empat sama:

di manakah parameter pemberat eksponen, atau parameter "faktor lupa".

Parameter dikemas kini menggunakan formula di bawah:

RMSProp telah menunjukkan penyesuaian yang sangat baik bagi kadar pembelajaran merentas aplikasi yang berbeza. RMSProp boleh dianggap sebagai generalisasi Rprop dan ia juga mampu berfungsi dengan variasi keturunan kecerunan seperti kelompok mini, yang bertentangan dengan keturunan kecerunan biasa.

2. Pelaksanaan penurunan kecerunan stokastik

Pada peringkat ini, beberapa varian kecerunan stokastik akan dilaksanakan dalam bentuk kod atur cara dalam bahasa pengaturcaraan Python.

2.1 Pelaksanaan penurunan kecerunan stokastik standard

Pertama, anda memerlukan set data. Dalam kes ini, set data dibuat menggunakan perpustakaan Scikit-Learn:

algoritma pembelajaran stokastik kecerunan

daripada sklearn.datasets import make_moons

daripada sklearn.cross_validation import train_test_split

X, y = make_moons(n_samples=5000, random_state=42, hingar=0.1)

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

Inilah yang kami dapat:

Rajah 1 - Perwakilan grafik bagi set data

Seterusnya, model rangkaian saraf ditentukan. Ini akan menjadi tiga lapisan rangkaian (satu lapisan tersembunyi):

import numpy sebagai np

def make_network(n_hidden=100):

model = dict(W1=np.random.randn(n_feature, n_hidden),

W2=np.random.randn(n_hidden, n_class)

Ia juga mentakrifkan dua operasi: perambatan ke hadapan dan perambatan belakang. Mari kita lakukan pilihan pertama dahulu:

kembalikan np.exp(x) / np.exp(x).sum()

def ke hadapan(x, model):

h = x @model["W1"]

prob = softmax(h @ model["W2"])

Litar mesti membuat satu siri titik dari input ke lapisan tersembunyi dan kemudian ke lapisan output. Dalam lapisan tersembunyi, tidak linear juga boleh digunakan supaya rangkaian saraf boleh meramalkan sempadan keputusan bukan linear. Wakil terkemuka bagi fungsi tak linear hari ini ialah ReLU.

ReLU ditakrifkan sebagai f(x)=max(0,x), tetapi bukannya melakukan np.max(0, x), terdapat helah pelaksanaan yang kemas: x = 0.

Apabila lapisan keluaran telah dicapai, output mestilah sedemikian rupa sehingga taburan kebarangkalian Bernoulli adalah tepat, jadi output dinyahmampat menggunakan fungsi SoftMax untuk mendapatkan taburan yang diberikan.

Sekarang operasi kedua ditakrifkan. Backpropagation kelihatan seperti ini:

def ke belakang(model, xs, hs, errs):

dW2 = hs.T @ kesilapan

dh = kesilapan @ model["W2"].T

dh = 0

pulangkan dict(W1=dW1, W2=dW2)

Asas algoritma dicipta. Fungsi sgd sedang dilaksanakan. Ia kelihatan seperti ini:

def sgd(model, X_train, y_train, batch_size):

untuk iter dalam julat(n_iter):

print("Lelaran ()".format(iter))

X_train, y_train = shuffle(X_train, y_train)

untuk i dalam julat(0, X_train.shape, batch_size):

X_train_mini = X_train

y_train_mini = y_train

model = sgd_step(model, X_train_mini, y_train_mini)

model pulangan

Fungsi sgd_step sedang dilaksanakan. Ia kelihatan seperti ini:

def sgd_step(model, X_train, y_train):

grad = get_batch_grad(model, X_train, y_train)

model = model.copy()

untuk lapisan dalam gred:

model += kadar_pembelajaran * gred

Fungsi get_batch_grad sedang dilaksanakan. Ia kelihatan seperti ini:

def get_batch_grad(model, X_train, y_train):

xs, hs, errs = , ,

untuk x, cls_idx dalam zip(X_train, y_train):

h, y_pred = hadapan(x, model)

y_true = np.zeros(n_class)

y_benar = 1.

err = y_true - y_pred

errs.append(err)

kembali ke belakang(model, np.array(xs), np.array(hs), np.array(errs))

Dalam fungsi ini, setiap titik data dalam kelompok diulang, kemudian dihantar ke rangkaian dan hasil label sebenar yang diperolehi oleh data latihan dibandingkan. Ralat ditentukan oleh perbezaan antara kebarangkalian label sebenar dan kebarangkalian ramalan kami.

2.2 Pelaksanaan Momentum

Momentum berfungsi berdasarkan prinsip undang-undang pergerakan fizikal, ia melalui optima tempatan (bukit-bukit kecil). Menambah momentum akan menyebabkan algoritma menumpu lebih cepat, kerana kelajuan terkumpul dan langkah kaedah boleh lebih besar daripada langkah malar dalam kaedah konvensional.

Memandangkan templat program sudah sedia, anda hanya perlu melaksanakan fungsi utama kaedah ini. Fungsi momentum diberikan di bawah:

def momentum(model, X_train, y_train, batch_size):

halaju = (k: np.zeros_like(v) untuk k, v dalam model.items())

gamma =.9

X_mini, y_mini = kelompok

untuk lapisan dalam gred:

halaju = gamma * halaju + alfa * gred

model += halaju

Pembolehubah halaju baharu didayakan yang akan mengumpul momentum untuk setiap parameter. Pembolehubah akan dikemas kini dengan istilah alpha*grad pada setiap langkah baru penurunan kecerunan. Terdapat juga sedikit penurunan dalam nilai pembolehubah halaju, yang dikira dalam langkah sebelumnya, menggunakan pekali gamma.

2.3 Pelaksanaan AdaGrad

Sehingga kini, kadar pembelajaran alfa diabaikan kerana ia tetap. Masalah timbul bahawa kadar pembelajaran mempengaruhi semua parameter dan algoritma tidak selalu berfungsi dengan cekap pada kadar pembelajaran yang berterusan. AdaGrad boleh menjadi penyelesaian kepada masalah ini.

Apabila menggunakan AdaGrad, pengemaskinian parameter berlaku mengikut arah, jadi kadar pembelajaran ialah parameter penyesuaian.

Pelaksanaan kaedah ini sedang dijalankan. Keseluruhan program sudah sedia, anda hanya perlu menukar fungsi utama. Ia akan dipanggil adagrad. Fungsi ditunjukkan di bawah:

def adagrad(model, X_train, y_train, batch_size):

kelompok = get_batch(X_train, y_train, batch_size)

untuk iter dalam julat(1, n_iter + 1):

idx = np.random.randint(0, len(batch))

X_mini, y_mini = kelompok

grad = get_batch_grad(model, X_mini, y_mini)

cache[k] += gred[k]**2

model pulangan

Anda dapat melihat bahawa kadar pembelajaran semakin normal. Ia kini boleh menjadi lebih besar atau lebih kecil bergantung pada cara kecerunan terkini berkelakuan.

2.4 Pelaksanaan RMSProp

Anda boleh perhatikan bahawa dalam bahagian terkumpul Adagrad, nilai cache[k] += grad[k]**2 meningkat secara monoton akibat daripada jumlah dan kuasa dua. Ini boleh menjadi masalah kerana kadar pembelajaran akan menurun secara monoton kepada kadar pembelajaran yang sangat kecil.

Untuk mengatasi masalah ini, RMSProp menguraikan nilai kecerunan terkumpul lalu supaya hanya sebahagian daripada kecerunan terkini dipertimbangkan. Kini, daripada mempertimbangkan semua kecerunan terkini, RMSProp berkelakuan seperti purata bergerak.

Pelaksanaan kaedah ini sedang dijalankan. Keseluruhan program sudah sedia, anda hanya perlu menukar fungsi utama. Ia akan dipanggil rmsprop. Fungsi ditunjukkan di bawah:

def rmsprop(model, X_train, y_train, batch_size):

cache = (k: np.zeros_like(v) untuk k, v dalam model.items())

gamma =.9

kelompok = get_batch(X_train, y_train, batch_size)

untuk iter dalam julat(1, n_iter + 1):

idx = np.random.randint(0, len(batch))

X_mini, y_mini = kelompok

grad = get_batch_grad(model, X_mini, y_mini)

cache[k] = gamma * cache[k] + (1 - gamma) * (grad[k]**2)

model[k] += alpha * grad[k] / (np.sqrt(cache[k]) + eps)

Perbezaan utama adalah dalam mengira nilai cache[k] dan kini nilai kecerunan terkumpul tidak akan meningkat secara agresif secara monoton.

3. Pengujian dan perbandingan

Bab ini akan menguji pelaksanaan dan menganalisis keputusan yang diperoleh.

3.1 Menguji penurunan kecerunan stokastik standard

Pada peringkat ini, penurunan kecerunan stokastik standard akan diuji. Prosedur akan dilakukan 100 kali dan kemudian ketepatan purata akan dikira.

n_eksperimen = 100

accs = np.zeros(n_experiment)

untuk k dalam julat(n_eksperimen):

model = make_network()

model = sgd(model, X_train, y_train, minibatch_size)

kuar = hadapan(x, model)

y = np.argmax(prob)

Selepas menjalankan kod ini, saya mendapat nilai berikut:

Purata ketepatan: 0.8765040000000001

Oleh itu, kita boleh membuat kesimpulan bahawa ketepatan pelaksanaan purata ialah 87%.

3.2 Momentum Ujian

Pada peringkat ini, penurunan kecerunan stokastik akan diuji berdasarkan pelaksanaan Momentum. Prosedur akan dilakukan 100 kali dan kemudian ketepatan purata akan dikira.

Program ujian diberikan di bawah:

n_eksperimen = 100

accs = np.zeros(n_experiment)

untuk k dalam julat(n_eksperimen):

model = make_network()

model = momentum(model, X_train, y_train, minibatch_size)

y_pred = np.zeros_like(y_test)

untuk i, x dalam enumerate(X_test):

kuar = hadapan(x, model)

y = np.argmax(prob)

accs[k] = (y_pred == y_test).sum() / y_test.size

print("Ketepatan purata: (), Nilai yang diterima: ()". format(accs.mean(), accs.std()))

Ketepatan purata:

1) 0.3152, dengan alfa = 0.5

2) 0.8554666666666666, dengan alfa = 1e-2

3) 0.8613333333333334, dengan alfa = 1e-5

Oleh itu, kita boleh membuat kesimpulan bahawa pada nilai yang lebih rendah daripada kadar pembelajaran, ketepatan pelaksanaan adalah lebih tinggi.

3.3 Pengujian AdaGrad

Pada peringkat ini, kami akan menguji penurunan kecerunan stokastik berdasarkan pelaksanaan AdaGrad. Prosedur akan dilakukan 100 kali dan kemudian ketepatan purata akan dikira.

Program ujian diberikan di bawah:

n_eksperimen = 100

accs = np.zeros(n_experiment)

untuk k dalam julat(n_eksperimen):

model = make_network()

model = adagrad(model, X_train, y_train, minibatch_size)

y_pred = np.zeros_like(y_test)

untuk i, x dalam enumerate(X_test):

kuar = hadapan(x, model)

y = np.argmax(prob)

accs[k] = (y_pred == y_test).sum() / y_test.size

print("Ketepatan purata: (), Nilai yang diterima: ()". format(accs.mean(), accs.std()))

Dengan melaksanakan kod ini, nilai berikut diperoleh:

Ketepatan purata:

1) 0.8754666666666667, dengan alfa = 0.5

2) 0.8786666666666667, dengan alfa = 1e-2

3) 0.504, dengan alfa = 1e-5

Oleh itu, kita boleh membuat kesimpulan bahawa pada nilai kadar pembelajaran yang sangat rendah, ketepatan pelaksanaan sangat berkurangan.

3.4 Menguji RMSProp

Pada peringkat ini, penurunan kecerunan stokastik akan diuji berdasarkan pelaksanaan RMSProp. Prosedur akan dilakukan 100 kali dan kemudian ketepatan purata akan dikira.

Program ujian diberikan di bawah:

n_eksperimen = 100

accs = np.zeros(n_experiment)

untuk k dalam julat(n_eksperimen):

model = make_network()

model = rmsprop(model, X_train, y_train, minibatch_size)

y_pred = np.zeros_like(y_test)

untuk i, x dalam enumerate(X_test):

kuar = hadapan(x, model)

y = np.argmax(prob)

accs[k] = (y_pred == y_test).sum() / y_test.size

print("Ketepatan purata: (), Nilai yang diterima: ()". format(accs.mean(), accs.std()))

Dengan melaksanakan kod ini, nilai berikut diperoleh:

Ketepatan purata:

1) 0.8506666666666667, dengan alfa = 0.5

2) 0.8727999999999999, dengan alfa = 1e-2

3) 0.30693333333333334, dengan alfa = 1e-5

Oleh itu, kita boleh membuat kesimpulan bahawa pada nilai kadar pembelajaran yang sangat rendah, ketepatan pelaksanaannya, serupa dengan AdaGrad, sangat berkurangan.

Kesimpulan

Daripada analisis perbandingan adalah jelas bahawa apabila menggunakan kadar pembelajaran yang besar, kaedah dengan kadar pembelajaran adaptif mengatasi kaedah dengan kadar pembelajaran yang tetap.

Walau bagaimanapun, sebaliknya berlaku apabila menggunakan nilai kadar pembelajaran yang kecil, seperti 1e-5. Untuk varian standard keturunan kecerunan stokastik dan kaedah momentum, nilai yang cukup kecil membolehkannya berfungsi dengan baik. Sebaliknya, jika kadar pembelajaran sangat kecil, dan ia dinormalisasi dalam kaedah kadar pembelajaran adaptif, maka ia menjadi lebih kecil, yang menjejaskan kadar penumpuan. Ini menjadikan latihan sangat perlahan, dan kaedah ini berprestasi lebih teruk daripada keturunan kecerunan stokastik standard dengan bilangan lelaran yang sama.

Senarai sumber yang digunakan

1. Machinelearning - Penurunan Kecerunan Stokastik

2. Kecerdasan buatan dalam bahasa Rusia - Keturunan kecerunan

3. Tutorial Wiki - Pelaksanaan algoritma/keturunan Kecerunan

4. Universiti Stanford - Kaedah Subgradien Suai Suai

5. Cambridge University Press - Algoritma Dalam Talian dan Anggaran Stokastik

6. Sanjoy Dasgupta dan David Mccallester - Mengenai kepentingan permulaan dan momentum dalam pembelajaran mendalam [Sumber elektronik].

Disiarkan di Allbest.ru

...

Dokumen yang serupa

Syarat yang diperlukan untuk ekstrem. Pembangunan algoritma mesin dan program pengoptimuman pelbagai dimensi untuk kaedah kecerunan menggunakan kaedah carian seragam. Menyemak syarat yang diperlukan dan mencukupi untuk ekstrem untuk titik minimum yang ditemui.

kerja kursus, ditambah 09/25/2013


Pelaksanaan perisian aplikasi untuk mengira fungsi tertentu. Prosedur untuk mencari minimum fungsi. Penggunaan kaedah Hooke-Jeeves dan turunan kecerunan untuk menyelesaikan masalah. Mengkaji fungsi di sekitar titik asas, menentukan koordinatnya.

ujian, ditambah 02/02/2014


Pengoptimuman penyelesaian masalah menggunakan algoritma penyepuhlindapan. Analisis teori pengoptimuman sebagai fungsi objektif. Kaedah penurunan kecerunan. Pembolehubah dan perihalan algoritma penyepuhlindapan. Perwakilan masalah jurujual kembara melalui graf. Mengurangkan masalah kepada pembolehubah dan menyelesaikannya.

kerja kursus, ditambah 05/21/2015


Latihan rangkaian saraf tiruan yang paling mudah dan berbilang lapisan. Kaedah latihan perceptron berdasarkan prinsip penurunan kecerunan di sepanjang permukaan ralat. Pelaksanaan dalam produk perisian NeuroPro 0.25. Menggunakan algoritma perambatan balik.

kerja kursus, ditambah 05/05/2015


Menyelesaikan masalah memaksimumkan fungsi beberapa pembolehubah. Penerangan kaedah dikotomi, aplikasinya untuk menyelesaikan persamaan tak linear. Menyelesaikan masalah ini menggunakan kaedah penurunan koordinat. Merangka algoritma, menyenaraikan program.

kerja kursus, ditambah 10/01/2009


Pengenalpastian objek menggunakan kaedah kuasa dua terkecil. Analisis pekali korelasi berpasangan, separa dan berbilang. Pembinaan model linear dan model dengan parameter teragih. Kaedah berangka berulang untuk mencari punca (sifar) bagi fungsi tertentu.

kerja kursus, ditambah 03/20/2014


Asas teknologi untuk menggunakan pakej perisian LabVIEW, kelebihan sistem. Pengaturcaraan berdasarkan seni bina aliran data. Kaedah untuk mencari ekstrem. Menggunakan kaedah Gauss-Seidel untuk mencari maksimum fungsi dua dimensi.

ujian, ditambah 03/18/2011


Tujuan dan klasifikasi kaedah pengoptimuman enjin carian. Kecekapan kaedah carian. Kaedah carian tertib sifar: input, syarat, keburukan dan aplikasi. Struktur kaedah carian kecerunan. Idea utama kaedah keturunan paling curam.

kuliah, ditambah 03/04/2009


Pernyataan masalah dan pemformalannya. Mencari nilai polinomial interpolasi pada titik x1 dan x2. Mencari minimum fungsi F(x) pada segmen itu. Menyemak keadaan penumpuan kaedah. Pengujian modul perisian. Gambar rajah terperinci algoritma.

kerja kursus, ditambah 02/04/2011


Kaedah berangka dalam masalah tanpa sekatan. Skim kaedah keturunan. Persekitaran Editor Asas Visual. Menggunakan objek ActiveX dalam bentuk. Carta alir algoritma simulasi. Masalah pengoptimuman untuk fungsi deterministik dengan satu titik ekstrem.