Stochastische Gradientenabstieg-Implementierung mit Python's numpy

Question

Ich muss stochastischen Gradientenabstieg mit Python-Numpy-Bibliothek implementieren. Zu diesem Zweck habe ich die folgenden Funktionsdefinitionen gegeben:

def compute_stoch_gradient(y, tx, w): 
    """Compute a stochastic gradient for batch data.""" 

def stochastic_gradient_descent(
     y, tx, initial_w, batch_size, max_epochs, gamma): 
    """Stochastic gradient descent algorithm.""" 

ich auch die folgenden Hilfefunktion gegeben habe:

def batch_iter(y, tx, batch_size, num_batches=1, shuffle=True): 
    """ 
    Generate a minibatch iterator for a dataset. 
    Takes as input two iterables (here the output desired values 'y' and the input data 'tx') 
    Outputs an iterator which gives mini-batches of `batch_size` matching elements from `y` and `tx`. 
    Data can be randomly shuffled to avoid ordering in the original data messing with the randomness of the minibatches. 
    Example of use : 
    for minibatch_y, minibatch_tx in batch_iter(y, tx, 32): 
     <DO-SOMETHING> 
    """ 
    data_size = len(y) 

    if shuffle: 
     shuffle_indices = np.random.permutation(np.arange(data_size)) 
     shuffled_y = y[shuffle_indices] 
     shuffled_tx = tx[shuffle_indices] 
    else: 
     shuffled_y = y 
     shuffled_tx = tx 
    for batch_num in range(num_batches): 
     start_index = batch_num * batch_size 
     end_index = min((batch_num + 1) * batch_size, data_size) 
     if start_index != end_index: 
      yield shuffled_y[start_index:end_index], shuffled_tx[start_index:end_index] 

I implementiert die folgenden zwei Funktionen:

def compute_stoch_gradient(y, tx, w): 
    """Compute a stochastic gradient for batch data.""" 
    e = y - tx.dot(w) 
    return (-1/y.shape[0])*tx.transpose().dot(e) 


def stochastic_gradient_descent(y, tx, initial_w, batch_size, max_epochs, gamma): 
    """Stochastic gradient descent algorithm.""" 
    ws = [initial_w] 
    losses = [] 
    w = initial_w 
    for n_iter in range(max_epochs): 
     for minibatch_y,minibatch_x in batch_iter(y,tx,batch_size): 
      w = ws[n_iter] - gamma * compute_stoch_gradient(minibatch_y,minibatch_x,ws[n_iter]) 
      ws.append(np.copy(w)) 
      loss = y - tx.dot(w) 
      losses.append(loss) 

    return losses, ws 

Ich bin mir nicht sicher, ob die Iteration im Bereich (max_epochs) oder in einem größeren Bereich durchgeführt werden soll. Ich sage das, weil ich gelesen habe, dass eine Epoche "jedes Mal, wenn wir den gesamten Datensatz durchlaufen" ist. Ich denke also, eine Epoche besteht aus mehr als einer Iteration ...

Answer 1

In einer typischen Implementierung sollte ein Mini-Batch-Gradientenabfall mit Batchgröße B zufällig B Datenpunkte aus dem Datensatz auswählen und die Gewichte basierend auf dem berechneten aktualisieren Gradienten auf dieser Teilmenge. Dieser Prozess selbst wird viele Male bis zur Konvergenz oder einer maximalen Schwellenwert-Iteration fortgesetzt. Mini-Batch mit B = 1 ist SGD, die manchmal laut sein kann.

Zusammen mit den obigen Kommentaren möchten Sie vielleicht mit der Batch-Größe und der Lernrate (Schrittgröße) spielen, da sie einen signifikanten Einfluss auf die Konvergenzrate von Stochastic- und Mini-Batch-Gradienten-Abstieg haben.

Die folgenden Diagramme zeigen die Auswirkungen dieser beiden Parameter auf die Konvergenzrate von SGD mit logistic regression während Sie Sentiment-Analyse auf amazon Testbericht Datensatz eine Zuordnung, die in einem Coursera Kurs auf Machine Learning erschien - Klassifizierung von der University of Washington :

Nähere Informationen hierzu Sie https://sandipanweb.wordpress.com/2017/03/31/online-learning-sentiment-analysis-with-logistic-regression-via-stochastic-gradient-ascent/?frame-nonce=987e584e16