Mini-toplu eğitim sinir ağları için rastgele seçilen eğitim örnekleri değiştirilmeden mi çekilmelidir?

Bir çağı, mevcut tüm eğitim örneklerinin tamamından geçmiş olarak ve mini-parti boyutunu, degradeyi azaltmak için gereken ağırlık / sapma güncellemelerini bulmak için ortalama örnek sayısı olarak tanımlarız.

Benim sorum, bir çığır içindeki her bir mini partiyi üretmek için bir dizi eğitim örneği yerine getirilmememiz gerekip gerekmediğidir. Dönem sonu gereksinimini karşılamak için aslında "tüm örnekleri çizdiğimizden" emin olmak için değiştirmekten kaçınmamız gerektiğini hissediyorum, ancak kesin bir cevabı şu veya bu şekilde bulmakta zorlanıyorum.

Google'ı okumayı ve okumayı denedim. Nielsen'in Sinir Ağları ve Derin Öğrenme 1'i var, ancak net bir cevap bulamadık. Bu metinde Nielsen, rastgele örneklemenin değiştirilmeden yapıldığını belirtmez, ancak öyle olduğunu ima eder.

Dönemlerde eğitimin daha net bir şekilde resmileştirilmesi istenirse burada bulunabilir - /stats//a/141265/131630

Düzenleme: bu soru bana benziyordu ama beklentinin doğrusallığının bu duruma bağımsızlık kayıtsız olduğu gerçeği nasıl uygulanacağı belli değildi - Örnekleme ile veya olmadan gerçekleşmesi gerekir

— bobo
kaynak

Veriye özgü bir neden olmadığı sürece, nöral ağ eğitimi için mini parti her zaman değiştirilmeden çizilir. Fikir, degradeyi tüm veri kümesiyle hesaplayan toplu mod ile sadece bir rastgele kullanan SGD arasında bir yerde olmak istemenizdir.

— horaceT

SGD, rastgele bir örnek kullanmakla sınırlı değildir. Bu sürece çevrimiçi eğitim denir. "Degrade inişin aşırı bir sürümü, sadece 1'lik bir mini parti boyutu kullanmaktır ... Bu prosedür çevrimiçi, çevrimiçi veya artımlı öğrenme olarak bilinir." Ve ayrıca, "Stokastik degrade iniş adı verilen bir fikir öğrenmeyi hızlandırmak için kullanılabilir. Fikir, rastgele seçilmiş eğitim girdilerinin küçük bir örneği için [it] 'i hesaplayarak dientC gradyanını tahmin etmektir. msgstr "" "". ". gerçek eğimin hızlı bir şekilde iyi bir tahminini alabiliriz. Her iki alıntı da Nielsen Ch. 1.

— bobo

Yanıtlar:

Rastgele çekimlere dayanan (kaç tane ayrımcı Derin Sinir Ağına (DNN) karşı eğitildikleri) yinelemeli algoritmalar bağlamında değiştirme şemaları olan ve olmayan şemaların iyi bir teorik analizi burada bulunabilir

Kısacası, örnekleme çıkıyor olmadan değiştirilmesi, örnekleme daha hızlı yakınsama yol açar ile değiştirilmesi.

Burada sağladıkları oyuncak örneğine dayanarak kısa bir analiz yapacağım: Diyelim ki aşağıdaki objektif işlevi optimize etmek istiyoruz:

x_{opt} = \underset{x}{\arg min} \frac{1}{2} \sum_{i = 1}^{N} (x - y_{i})^{2}

$x_{\text{opt}} = \underset{x}{\arg\min} \frac{1}{2} \sum_{i=1}^{N}(x - y_i)^2$

burada hedef . Bu örnekte, etiketleri göz önüne alındığında , optimal için çözmeye çalışıyoruz . $y_i \sim \mathcal{N}(\mu, \sigma^2)$ $x$ $N$ $y_i$

Tamam, bu yüzden doğrudan yukarıdaki en uygun için çözecek olsaydık, burada kayıp fonksiyonunun türevini alır, 0'a ayarlar ve için . Yukarıdaki örneğimiz için kayıp $x$ $x$

L = \frac{1}{2} \sum_{i = 1}^{N} (x - y_{i})^{2}

$L = \frac{1}{2} \sum_{i=1}^{N}(x - y_i)^2$

ve ilk türev:

\frac{δ L}{δ x} = \sum_{i = 1}^{N} (x - y_{i})

$\frac{\delta L}{\delta x} = \sum_{i=1}^{N}(x - y_i)$

Ayar 0 ve çözme içinverimleri: $\frac{\delta L}{\delta x}$ $x$

x_{opt} = \frac{1}{N} \sum_{i = 1}^{N} y_{i}

$x_{\text{opt}} = \frac{1}{N} \sum_{i=1}^{N} y_i$

Başka bir deyişle, optimum çözüm tüm örneklerinin örnek ortalamasından başka bir şey değildir . $N$ $y$

Şimdi, yukarıdaki hesaplamayı bir kerede gerçekleştiremeseydik, bunu aşağıdaki gradyan iniş güncelleme denklemi aracılığıyla tekrar tekrar yapmamız gerekirdi:

x_{i} = x_{i - 1} - λ_{i} \nabla (f (x_{i - 1}))

$x_i = x_{i-1} - \lambda_i \nabla(f(x_{i-1}))$

ve basitçe terimlerimizi buraya eklemek:

x_{i} = x_{i - 1} - λ_{i} (x_{i - 1} - y_{i})

$x_{i} = x_{i-1} - \lambda_i (x_{i-1} - y_{i})$

Yukarıdaki tüm için çalıştırırsak , o zaman etkili bir şekilde bu güncelleştirmeyi performans olmadan değiştirilmesi. O zaman soru, optimum değerini bu şekilde elde edebilir miyiz ? ( optimal değerinin örnek ortalamasından başka bir şey olmadığını unutmayın ). izin verirseniz cevap evettir . Görmek için bunu genişletiyoruz: $i \in {1, 2, ... N}$ $x$ $x$ $y$ $\lambda_i = 1/i$

x_{i} = x_{i - 1} - λ_{i} (x_{i - 1} - y_{i}) x_{i} = x_{i - 1} - \frac{1}{i} (x_{i - 1} - y_{i}) x_{i} = \frac{i x_{i - 1} - (x_{i - 1} - y_{i})}{i} x_{i} = \frac{(i - 1) x_{i - 1} + y_{i}}{i} i x_{i} = (i - 1) x_{i - 1} + y_{i}

$x_{i} = x_{i-1} - \lambda_i (x_{i-1} - y_{i}) \\\ x_{i} = x_{i-1} - \frac{1}{i} (x_{i-1} - y_{i}) \\\ x_{i} = \frac{i x_{i-1} - (x_{i-1} - y_{i})}{i} \\\ x_{i} = \frac{(i - 1)x_{i-1} + y_{i}}{i} \\\ i x_{i} = (i - 1)x_{i-1} + y_{i} \\\$

$i=1$ $i=2$ $i=N$ , we would have performed our updates without replacement, and our update formula gives us the optimal solution of $x$ , which is the sample mean!

N x_{N} = (N - 1) x_{N - 1} + y_{N} ==> x_{N} = \frac{1}{N} \sum_{i = 1}^{N} y_{i} = μ

$N x_{N} = (N - 1)x_{N-1} + y_{N} ==> x_N = \frac{1}{N}\sum_{i=1}^{N} y_i = \mu$

In contrast however, if we actually drew with replacement, then while our draws would then be truly independent, the optimized value $x_N$ would be different from the (optimal) mean $\mu$ , and the square error would be given by:

E {(x_{N} - μ)^{2}}

$\mathop{E}\{(x_N - \mu)^2\}$

which is going to be a positive value, and this simple toy example can be extended to higher dimensions. This has the consequence that we would want to perform sampling without replacement as a more optimal solution.

Hope this clarifies it some more!

— Tarin Ziyaee
kaynak

This example uses quite a lot of assumptions, i.e. the use of squared error and convexity of the loss landscape. Does the result hold when those assumptions are not satisfied?

— bayerj

@bayerj This particular toy example, yes. However the paper goes on to extend it for some other further theoretical cases. I believe other sources [Boutou I think] show empirical support for without-replacement sampling being superior.

— Tarin Ziyaee

@TarinZiyaee Thanks for this answer - can you clarify λ_k=1/k? Which k are we talking about here, the k from the above equation? I didn't follow you here, which made following the subsequent summation and conclusion difficult. Thanks.

— bobo

@bobo I will try to clarify the post up tonight.

— Tarin Ziyaee

@bobo I updated my answer a bunch. Please take a look and let me know if that helps.

— Tarin Ziyaee

According to the code in Nielsen's repository, mini-batches are drawn without replacement:

    def SGD(self, training_data, epochs, mini_batch_size, eta, test_data=None):
    n = len(training_data)
    for j in range(epochs):
            random.shuffle(training_data)
            mini_batches = [
                training_data[k:k+mini_batch_size]
                for k in range(0, n, mini_batch_size)
            ]
            for mini_batch in mini_batches:
                self.update_mini_batch(mini_batch, eta)

We can see that there is no replacement of training samples within an epoch. Interestingly, we can also see that Nielsen chooses not to worry about adjusting eta (the learning rate) for the last mini_batch size, which may not have as many training samples as the previous mini-batches. Presumably this is an advanced modification he leaves for later chapters.**

** EDIT: Actually, this scaling occurs in the def update_mini_batch function. For example, with the weights:

self.weights = [w-(eta/len(mini_batch))*nw for w, nw in zip(self.weights, nabla_w)]

This is necessary because the last mini_batch may be smaller than the previous mini_batches if the number of training samples per mini_batch does not divide evenly into the total number of training samples available.

mylist = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
n = len(mylist)
mini_batch_size = 2
mini_batches = [
    mylist[k:k+mini_batch_size]
    for k in range(0, n, mini_batch_size)
    ]
for mini_batch in mini_batches:
    print(mini_batch)

Output:

['1', '2']
['3', '4']
['5', '6']
['7', '8']
['9', '10']

Changing mini_batch_size to 3, which does not divide evenly into our 10 training samples. For output we get:

['1', '2', '3']
['4', '5', '6']
['7', '8', '9']
['10']

When evaluating a range over list indices (something of the form [x:y] where x and y are some indices into the list), if our right-hand value exceeds the list length, python simply returns the items from the list up until the value goes out of index range.

So the last mini-batch might be smaller than previous mini-batches, but if it is weighted by the same eta then those training samples will contribute more to the learning than samples in the other, larger mini-batches. Since this is just the last mini-batch it's probably not worth worrying about too much, but can easily be solved by scaling eta to the length of the mini-batch.

— bobo
kaynak