Sollten Trainingsmuster, die zufällig für Mini-Batch-Trainingsnetze gezogen wurden, ersatzlos gezogen werden?

Wir definieren eine Epoche, in der alle verfügbaren Trainingsmuster durchlaufen wurden, und die Mini-Batch-Größe als die Anzahl der Muster, über die wir den Durchschnitt bilden, um die Aktualisierungen der Gewichte / Vorspannungen zu finden, die zum Abstieg des Gradienten erforderlich sind.

Meine Frage ist, ob wir aus den Trainingsbeispielen ersatzlos schöpfen sollten, um jede Mini-Charge innerhalb einer Epoche zu generieren. Meines Erachtens sollten wir Ersatz vermeiden, um sicherzustellen, dass wir tatsächlich "alle Proben ziehen", um die End-of-Epoch-Anforderung zu erfüllen, aber es fällt uns schwer, auf die eine oder andere Weise eine endgültige Antwort zu finden.

Ich habe versucht zu googeln und zu lesen. 1 von Nielsens Neuronalen Netzen und Deep Learning haben aber keine klare Antwort gefunden. In diesem Text gibt Nielsen nicht an, dass die Zufallsstichprobe ersatzlos durchgeführt wird, sondern scheint dies zu implizieren.

Eine klarere Formalisierung der Ausbildung in Epochen finden Sie hier, falls gewünscht - /stats//a/141265/131630

Bearbeiten: Diese Frage schien mir ähnlich, aber es war unklar, wie man die Tatsache, dass Linearität der Erwartung für die Unabhängigkeit gleichgültig ist, auf diese Situation anwenden soll - Sollte die Stichprobe mit oder ohne Ersatz erfolgen

Eine gute theoretische Analyse von mit und ohne Ersetzungsschemata im Kontext von iterativen Algorithmen auf der Basis von Zufallszügen (gegen die wie viele diskriminative Deep Neural Networks (DNNs) trainiert werden) kann hier gefunden werden

Kurz gesagt stellt sich heraus, dass eine Abtastung ohne Ersatz zu einer schnelleren Konvergenz führt als eine Abtastung mit Ersatz.

Ich werde hier eine kurze Analyse anhand des von ihnen bereitgestellten Spielzeugbeispiels geben: Nehmen wir an, wir möchten die folgende Zielfunktion optimieren:

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

wo das Ziel . In diesem Beispiel versuchen wir, für das optimale zu lösen , wobei offensichtlich Bezeichnungen von .x N y $y_i \sim \mathcal{N}(\mu, \sigma^2)$$x$$N$$y_i$

Ok, wenn wir also direkt nach dem optimalen im obigen Beispiel auflösen würden, würden wir die Ableitung der Verlustfunktion hier nehmen, auf 0 setzen und nach . In unserem obigen Beispiel ist der Verlust also$x$$x$

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

und es ist die erste Ableitung wäre:

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

Wenn Sie auf 0 setzen und nach auflösen, erhalten Sie:$\frac{\delta L}{\delta x}$$x$

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

Mit anderen Worten, die optimale Lösung ist nichts anderes als der Stichprobenmittelwert aller Stichproben von .$N$$y$

Wenn wir die obige Berechnung nicht auf einmal durchführen könnten, müssten wir sie rekursiv über die unten stehende Gleichung zur Aktualisierung des Gefälleverlaufs ausführen:

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

Wenn Sie hier einfach unsere Begriffe einfügen, erhalten Sie:

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

Wenn wir das Obige für alle ausführen, führen wir dieses Update tatsächlich ohne Ersatz durch. Dann stellt sich die Frage, ob wir auf diese Weise auch den optimalen Wert von können. (Denken Sie daran, dass der optimale Wert von nichts anderes ist als der Stichprobenmittelwert von ). Die Antwort lautet ja, wenn Sie . Um dies zu sehen, erweitern wir: x x y λ i = 1 /$i \in {1, 2, ... N}$$x$$x$$y$$\lambda_i = 1/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} \\\ $$

Die letzte Gleichung ist jedoch nichts anderes als die Formel für den laufenden Durchschnitt! Wenn wir also die Menge von , usw. bis zu durchlaufen , hätten wir unsere Aktualisierungen ohne Ersetzung durchgeführt, und unsere Aktualisierungsformel gibt uns die optimale Lösung von , d. H Probe bedeuten!$i=1$$i=2$$i=N$$x$

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

Aber im Gegensatz dazu , wenn wir tatsächlich zogen mit Ersatz, dann während unseres zieht wäre dann wirklich unabhängig sein, der optimierte Wert wäre anders , von dem (optimal) Mittelwert , und der quadratischen Fehler würde gegeben sein:$x_N$$\mu$

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

Das wird ein positiver Wert, und dieses einfache Spielzeugbeispiel kann auf höhere Dimensionen ausgedehnt werden. Dies hat zur Folge, dass wir die Probenahme ersatzlos als optimalere Lösung durchführen möchten.

Hoffe das klärt es noch ein wenig!

Gemäß dem Code im Nielsen-Repository werden Minibatches ersatzlos gezeichnet:

    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)

Wir können sehen, dass es innerhalb einer Epoche keinen Ersatz für Trainingsmuster gibt. Interessanterweise können wir auch feststellen, dass Nielsen sich keine Gedanken über die Anpassung eta(der Lernrate) für die letzte mini_batch-Größe macht, die möglicherweise nicht so viele Schulungsbeispiele enthält wie die vorherigen Mini-Batches. Vermutlich ist dies eine fortgeschrittene Modifikation, die er für spätere Kapitel hinterlässt. **

** EDIT: Eigentlich tritt diese Skalierung in der def update_mini_batchFunktion auf. Zum Beispiel mit den Gewichten:

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

Dies ist erforderlich, da der letzte mini_batch möglicherweise kleiner als die vorherigen mini_batches ist, wenn sich die Anzahl der Trainingsmuster pro mini_batch nicht gleichmäßig auf die Gesamtzahl der verfügbaren Trainingsmuster aufteilt.

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)

Ausgabe:

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

Wechseln mini_batch_sizezu 3, was sich nicht gleichmäßig in unsere 10 Trainingsmuster aufteilt. Für die Ausgabe erhalten wir:

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

Wenn eine Reihe über Listenindex (etwas von der Form der Bewertung , [x:y]wo xund ysind einige Indizes in die Liste), wenn unser rechter Wert die Liste Länge überschreitet, gibt Python einfach die Elemente aus der Liste nach oben , bis der Wert des Indexbereiches geht .

Der letzte Mini-Batch ist möglicherweise kleiner als die vorherigen Mini-Batches. Wenn er jedoch mit demselben etaGewicht versehen wird, tragen diese Trainingsmuster mehr zum Lernen bei als die Muster in den anderen größeren Mini-Batches. Da dies nur die letzte Mini-Charge ist, lohnt es sich wahrscheinlich nicht, sich zu viele Gedanken zu machen, sondern kann einfach durch Skalieren etaauf die Länge der Mini-Charge gelöst werden .