Coursera ML - Implementieren regulierte logistische Regression Kostenfunktion in Python

Question

Ich arbeite durch Andrew Ng Machine Learning auf Coursera durch die Implementierung aller Code in Python und nicht MATLAB.

In Programmierung Übung 3 implementierte ich meine gesetzlich geregelte Funktion logistische Regression Kosten in einer vektorisierten Form:

def compute_cost_regularized(theta, X, y, lda): 
    reg =lda/(2*len(y)) * np.sum(theta**2) 
    return 1/len(y) * np.sum(-y @ np.log(sigmoid(X@theta)) 
         - (1-y) @ np.log(1-sigmoid(X@theta))) + reg 

Auf den folgenden Testeingänge:

theta_test = np.array([-2,-1,1,2]) 
X_test = np.concatenate((np.ones((5,1)), 
     np.fromiter((x/10 for x in range(1,16)), float).reshape((3,5)).T), axis = 1) 
y_test = np.array([1,0,1,0,1]) 
lambda_test = 3 

die oben Kostenfunktion Ausgänge 3.734819396109744. Nach dem uns zur Verfügung gestellten MATLAB-Code sollte die korrekte Ausgabe jedoch 2.534819 lauten. Ich bin verwirrt, weil ich mit meiner Kostenfunktion nichts falsch finde, aber ich glaube, dass es einen Fehler hat. In der Tat habe ich auch implemented it in Programming Exercise 2 in der binären Klassifizierung Fall und es funktioniert gut, was eine result close to the expected value.

Ich dachte, dass ein Grund dafür sein könnte, dass ich falsch meine *_test Eingabefelder aufgebaut haben, basierend auf dem mitgelieferten Skelett MATLAB-Code falsch interpretiert, die sind:

theta_t = [-2; -1; 1; 2]; 
X_t = [ones(5,1) reshape(1:15,5,3)/10]; 
y_t = ([1;0;1;0;1] >= 0.5); 
lambda_t = 3; 

Allerdings hatte ich sie durch einen Octave Dolmetscher lief zu Sehen Sie, was sie wirklich sind, und stellen Sie sicher, dass ich sie genau in Python zuordnen konnte.

Darüber hinaus ist auch die Berechnung von Gradienten basierend auf diesen Eingaben mit meiner eigenen vektorisierten und regulierten Gradientenfunktion korrekt. Schließlich habe ich beschlossen, einfach mit der Berechnung fortzufahren und die Vorhersageergebnisse zu untersuchen. Die Genauigkeit meiner Vorhersagen war viel niedriger als die erwartete Genauigkeit, so dass es mehr Grund zu der Annahme gibt, dass etwas mit meiner Kostenfunktion nicht stimmt, die alles andere falsch macht.

Hilfe bitte! Vielen Dank.

Answer 1

Wenn Sie von der Regularisierung zurückrufen, tun Sie nicht regularize den Bias-Koeffizienten. Sie stellen den Gradienten nicht nur auf Null, wenn Sie Gradientenabfall durchführen, sondern Sie berücksichtigen dies nicht in der Kostenfunktion. Sie haben einen kleinen Fehler, wenn Sie dies als Teil der Summe (siehe Zelle # 18 auf Ihrem Notebook, die Sie verknüpft haben - die Summe sollte von j = 1 beginnen, aber Sie haben es als j = 0). Daher müssen Sie vom zweiten Element bis zum Ende für Ihre theta summieren, nicht die erste. Sie können dies auf Seite 9 der PDF-Zuweisung ex2.pdf überprüfen, die in Ihrem Github-Repository angezeigt wird. Dies erklärt die überhöhten Kosten, da Sie die Verzerrungseinheit als Teil der Regularisierung einbeziehen.

Wenn daher in reg Regularisierung Berechnung Index theta, so dass Sie von dem zweiten Element beginnen und weiter:

def compute_cost_regularized(theta, X, y, lda): 
    reg =lda/(2*len(y)) * np.sum(theta[1:]**2) # Change here 
    return 1/len(y) * np.sum(-y @ np.log(sigmoid(X@theta)) 
         - (1-y) @ np.log(1-sigmoid(X@theta))) + reg 

Sobald ich dies tun, definieren Sie Ihre Testwerte sowie Ihre sigmoid Funktion definieren, I Erhalten Sie die richtige Antwort, die Sie erwarten:

In [8]: def compute_cost_regularized(theta, X, y, lda): 
    ...:  reg =lda/(2*len(y)) * np.sum(theta[1:]**2) 
    ...:  return 1/len(y) * np.sum(-y @ np.log(sigmoid(X@theta)) 
    ...:       - (1-y) @ np.log(1-sigmoid(X@theta))) + reg 
    ...: 

In [9]: def sigmoid(z): 
    ...:  return 1/(1 + np.exp(-z)) 
    ...: 

In [10]: theta_test = np.array([-2,-1,1,2]) 
    ...: X_test = np.concatenate((np.ones((5,1)), 
    ...:   np.fromiter((x/10 for x in range(1,16)), float).reshape((3,5)).T), axis = 1) 
    ...: y_test = np.array([1,0,1,0,1]) 
    ...: lambda_test = 3 
    ...: 

In [11]: compute_cost_regularized(theta_test, X_test, y_test, lambda_test) 
Out[11]: 2.5348193961097438