Gradientenabstieg mit Python und Numpy

Ich denke, dein code ist etwas zu kompliziert und es braucht mehr Struktur, weil sonst wirst du verloren sein in alle Gleichungen und Operationen. Am Ende dieser regression reduziert sich auf vier Operationen:

1. Berechnen Sie die Hypothese h = X * theta
2. Berechnung der Verlust - = h - y und vielleicht auch das Quadrat der Kosten (- Verlust^2)/2m
3. Berechnen Sie den Gradienten = X' * Verlust /m
4. Update der Parameter theta = theta - alpha * Steigung

In Ihrem Fall, ich denke, Sie verwechselt haben m mit n. Hier m bezeichnet die Anzahl der Beispiele in Ihrer Ausbildung setzen, nicht die Anzahl der features.

Let ' s haben einen Blick auf meine Variante von code:

import numpy as np
import random

# m denotes the number of examples here, not the number of features
def gradientDescent(x, y, theta, alpha, m, numIterations):
    xTrans = x.transpose()
    for i in range(0, numIterations):
        hypothesis = np.dot(x, theta)
        loss = hypothesis - y
        # avg cost per example (the 2 in 2*m doesn't really matter here.
        # But to be consistent with the gradient, I include it)
        cost = np.sum(loss ** 2) / (2 * m)
        print("Iteration %d | Cost: %f" % (i, cost))
        # avg gradient per example
        gradient = np.dot(xTrans, loss) / m
        # update
        theta = theta - alpha * gradient
    return theta


def genData(numPoints, bias, variance):
    x = np.zeros(shape=(numPoints, 2))
    y = np.zeros(shape=numPoints)
    # basically a straight line
    for i in range(0, numPoints):
        # bias feature
        x[i][0] = 1
        x[i][1] = i
        # our target variable
        y[i] = (i + bias) + random.uniform(0, 1) * variance
    return x, y

# gen 100 points with a bias of 25 and 10 variance as a bit of noise
x, y = genData(100, 25, 10)
m, n = np.shape(x)
numIterations= 100000
alpha = 0.0005
theta = np.ones(n)
theta = gradientDescent(x, y, theta, alpha, m, numIterations)
print(theta)

Zuerst erstelle ich eine kleine random dataset, das sollte dann so Aussehen:

Wie Sie sehen können ich habe auch die erzeugte Regressionsgerade und die Formel wurde berechnet durch excel.

Sie benötigen zu kümmern über, die intuition der regression mit Gradienten-Abstieg. Wie Sie eine vollständige batch-Durchlauf über Ihre Daten X, müssen Sie zur Verringerung der m-Verlusten jedes Beispiel auf eine einzelne Gewicht-update. In diesem Fall ist der Mittelwert der Summe über die Verläufe, so ist die division durch m.

Die nächste Sache, die Sie benötigen zu kümmern über, verfolgen die Annäherung und Anpassung der Lern-rate. Für diese Angelegenheit sollten Sie immer verfolgen Sie Ihre Kosten jeder iteration, vielleicht sogar zeichnen Sie es.

Wenn du mein Beispiel, das theta zurückgegeben wird wie folgt Aussehen:

Iteration 99997 | Cost: 47883.706462
Iteration 99998 | Cost: 47883.706462
Iteration 99999 | Cost: 47883.706462
[ 29.25567368   1.01108458]

Ist eigentlich ganz in der Nähe der Gleichung berechnet wurde, die von excel (y = x + 30). Beachten Sie, dass während wir an der Voreingenommenheit in der ersten Spalte, der ersten theta-Wert bezeichnet die Neigung Gewicht.

InformationsquelleAutor der Antwort Thomas Jungblut

Ich weiß, diese Frage bereits beantworten, aber ich habe einige update der GD-Funktion :

  ### COST FUNCTION

def cost(theta,X,y):
     ### Evaluate half MSE (Mean square error)
     m = len(y)
     error = np.dot(X,theta) - y
     J = np.sum(error ** 2)/(2*m)
     return J

 cost(theta,X,y)



def GD(X,y,theta,alpha):

    cost_histo = [0]
    theta_histo = [0]

    # an arbitrary gradient, to pass the initial while() check
    delta = [np.repeat(1,len(X))]
    # Initial theta
    old_cost = cost(theta,X,y)

    while (np.max(np.abs(delta)) > 1e-6):
        error = np.dot(X,theta) - y
        delta = np.dot(np.transpose(X),error)/len(y)
        trial_theta = theta - alpha * delta
        trial_cost = cost(trial_theta,X,y)
        while (trial_cost >= old_cost):
            trial_theta = (theta +trial_theta)/2
            trial_cost = cost(trial_theta,X,y)
            cost_histo = cost_histo + trial_cost
            theta_histo = theta_histo +  trial_theta
        old_cost = trial_cost
        theta = trial_theta
    Intercept = theta[0] 
    Slope = theta[1]  
    return [Intercept,Slope]

res = GD(X,y,theta,alpha)

Dieser Funktion reduzieren Sie die alpha über die iteration macht die Funktion zu konvergieren schneller sehen Die Schätzung der linearen regression mit Gradient Descent (Steilster Abstieg) für ein Beispiel in der R., die ich gelten die gleiche Logik, aber in Python.

InformationsquelleAutor der Antwort Nico Coallier