Wie implementiert man Mini-Batch-Gradienten-Abstieg in Python?

Question

Ich habe gerade angefangen, tiefes Lernen zu lernen. Ich habe mich festgefahren, als es zum Gradientenabstieg kam. Ich weiß, wie man Batch-Gradienten-Abstieg implementiert. Ich weiß, wie es funktioniert und wie die Minibatch- und stochastische Gradientenabsenkung in der Theorie funktioniert. Aber wirklich kann nicht verstehen, wie man im Code einführt.

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 Beispielcode von ANDREW TRASKs Blog. Es ist klein und leicht zu verstehen. Dieser Code implementiert Batch-Gradienten-Abstieg, aber ich möchte Mini-Batch und stochastischen Gradienten-Abstieg in diesem Beispiel implementieren. Wie könnte ich das tun? Was muss ich in diesem Code hinzufügen/ändern, um Minibatch bzw. stochastischen Gradientenabstieg zu implementieren? Ihre Hilfe wird mir sehr helfen. Vielen Dank im Voraus. (Ich weiß, dass dieser Beispielcode einige Beispiele hat, während ich große Datenmengen in Minibatches aufteilen muss. Aber ich würde gerne wissen, wie ich das implementieren kann)

Answer 1

Diese Funktion gibt die angegebenen Minibatches zurück 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 das sagt Ihnen, wie das verwenden, 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)) 

Offensichtlich müssen Sie die f_train, f_val und andere Funktionen selbst die Optimierung Bibliothek gegeben definieren (zB Lasagne , Keras), die du benutzt.