Wie implementieren von mini-batch gradient descent in python?

Ich habe gerade angefangen zu lernen, tiefes lernen. Fand ich mich stecken, wenn es darum ging, Gradienten-Abstieg. Ich weiß, wie das umzusetzen, batch gradient descent. Ich weiß, wie es funktioniert so gut, wie die mini-batch-und stochastic gradient descent funktioniert in der Theorie. Aber kann wirklich nicht verstehen, wie die Umsetzung in code.

import numpy as np
X = np.array([ [0,0,1],[0,1,1],[1,0,1],[1,1,1] ])
y = np.array([[0,1,1,0]]).T
alpha,hidden_dim = (0.5,4)
synapse_0 = 2*np.random.random((3,hidden_dim)) - 1
synapse_1 = 2*np.random.random((hidden_dim,1)) - 1
for j in xrange(60000):
    layer_1 = 1/(1+np.exp(-(np.dot(X,synapse_0))))
    layer_2 = 1/(1+np.exp(-(np.dot(layer_1,synapse_1))))
    layer_2_delta = (layer_2 - y)*(layer_2*(1-layer_2))
    layer_1_delta = layer_2_delta.dot(synapse_1.T) * (layer_1 * (1-layer_1))
    synapse_1 -= (alpha * layer_1.T.dot(layer_2_delta))
    synapse_0 -= (alpha * X.T.dot(layer_1_delta))

Dies ist der Beispiel-code von ANDREW TRASK ' s blog. Es ist klein und einfach zu verstehen. Dieser code implementiert batch gradient descent, aber ich möchte zu implementieren, mini-batch und stochastic gradient descent in diesem Beispiel. Wie könnte ich dies tun? Was ich noch hinzufügen/ändern in diesem code, um zu implementieren, mini-batch und stochastic gradient descent jeweils? Deine Hilfe wird mir sehr helfen. Vielen Dank im Voraus.( Ich weiß, dieser code hat nur wenige Beispiele, obwohl ich große datasets aufgeteilt in mini-batches. Aber ich würde gerne wissen, wie kann ich es umsetzen)

Nur Beispiel-ein mini-batch in Ihrem for-Schleife so ändern Sie den Namen des ursprünglichen X "wholeX" (und y) und innerhalb der Schleife tun, X, y = Probe(wholeX, wholeY, Größe)", wo die Probe wird Ihre Funktion zurückkehren "Größe" Anzahl der zufällige Zeilen aus wholeX, wholeY
Danke. Als Sie sagte, dass meine Funktion zurückgeben zufälliger Zeilen an, so ist es nicht möglich zurückgeben gleichen Zeilen mehrmals? Würde es ein problem verursachen? und was ist, wenn ich eine weitere for-Schleife innerhalb einer for-Schleife und Durchlaufen Sie n-mal. (n = mini-batches). Jedes mal, wenn X und y Verschieden sein. Ist es ok? Wenn es in Ordnung ist, dann wie es sich tatsächlich verbessert-Optimierung?
Stichproben ohne repeatition ist eine typische Lösung, und es ist nicht schwer zu erreichen angesichts der Tatsache numpy.zufällig hat diese Art der Stichprobenziehung umgesetzt. Eine weitere for-Schleife ist in Ordnung (wenn auch nicht effizient, da die python-Schleifen sind langsam). Verbesserung der Optimierung kommt aus mathematischen Gründen so lange hier zum Ausdruck bringen. Kurz gesagt, es gibt viele schlechte Schätzungen des Gradienten auf Kosten eines gutes, das macht die Optimierung schneller
Danke. Überschrift über mehr mathematische Sachen.

InformationsquelleAutor savan77 | 2016-07-02

Diese Funktion liefert den mini-Chargen gegeben, die Eingänge und Ziele:

def iterate_minibatches(inputs, targets, batchsize, shuffle=False):
    assert inputs.shape[0] == targets.shape[0]
    if shuffle:
        indices = np.arange(inputs.shape[0])
        np.random.shuffle(indices)
    for start_idx in range(0, inputs.shape[0] - batchsize + 1, batchsize):
        if shuffle:
            excerpt = indices[start_idx:start_idx + batchsize]
        else:
            excerpt = slice(start_idx, start_idx + batchsize)
        yield inputs[excerpt], targets[excerpt]

und dies sagt Ihnen, wie Sie zu verwenden, die für die Ausbildung:

for n in xrange(n_epochs):
    for batch in iterate_minibatches(X, Y, batch_size, shuffle=True):
        x_batch, y_batch = batch
        l_train, acc_train = f_train(x_batch, y_batch)

    l_val, acc_val = f_val(Xt, Yt)
    logging.info('epoch ' + str(n) + ' ,train_loss ' + str(l_train) + ' ,acc ' + str(acc_train) + ' ,val_loss ' + str(l_val) + ' ,acc ' + str(acc_val))

Natürlich müssen Sie definieren, die f_train, f_val und andere Funktionen, die sich angesichts der Optimierung der Bibliothek (z.B. Lasagne, Keras), die Sie verwenden.

Danke..jetzt verstehe ich das.

InformationsquelleAutor Ash

Die folgende Funktion gibt (Erträge), mini-batches. Es basiert auf der Funktion von Asche, sondern korrekt behandelt die letzten minibatch.

def iterate_minibatches(inputs, targets, batchsize, shuffle=False):
    assert inputs.shape[0] == targets.shape[0]
    if shuffle:
        indices = np.arange(inputs.shape[0])
        np.random.shuffle(indices)
    for start_idx in range(0, inputs.shape[0], batchsize):
        end_idx = min(start_idx + batchsize, inputs.shape[0])
        if shuffle:
            excerpt = indices[start_idx:end_idx]
        else:
            excerpt = slice(start_idx, end_idx)
        yield inputs[excerpt], targets[excerpt]

InformationsquelleAutor dsachar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.