Ich habe kürzlich Übung 3 von Andrew Ngs maschinellem Lernen auf Coursera mit Python abgeschlossen .
Als ich die Teile 1.4 bis 1.4.1 der Übung zum ersten Mal absolvierte, hatte ich Schwierigkeiten sicherzustellen, dass mein trainiertes Modell die Genauigkeit aufweist, die den erwarteten 94,9% entspricht. Selbst nachdem ich debuggt und sichergestellt hatte, dass meine Kosten- und Verlaufsfunktionen fehlerfrei waren und mein Prädiktorcode ordnungsgemäß funktionierte, erhielt ich immer noch eine Genauigkeit von nur 90,3%. Ich habe den Conjugate Gradient (CG) -Algorithmus in verwendet scipy.optimize.minimize.
Aus Neugier entschied ich mich für einen anderen Algorithmus und verwendete Broyden-Fletcher-Goldfarb-Shannon (BFGS). Zu meiner Überraschung verbesserte sich die Genauigkeit drastisch auf 96,5% und übertraf damit die Erwartungen. Der Vergleich dieser beiden unterschiedlichen Ergebnisse zwischen CG und BFGS kann in meinem Notizbuch unter der Überschrift Unterschied in der Genauigkeit aufgrund unterschiedlicher Optimierungsalgorithmen angezeigt werden .
Liegt der Grund für diesen Genauigkeitsunterschied in der unterschiedlichen Wahl des Optimierungsalgorithmus? Wenn ja, könnte jemand erklären, warum?
Außerdem würde ich mich über eine Überprüfung meines Codes sehr freuen, um sicherzustellen, dass in keiner meiner Funktionen ein Fehler vorliegt, der dies verursacht.
Vielen Dank.
BEARBEITEN: Hier unten habe ich den Code hinzugefügt, der in der Frage enthalten ist, auf Anfrage in den Kommentaren, die ich auf dieser Seite mache, anstatt die Leser auf die Links zu meinen Jupyter-Notizbüchern zu verweisen.
Modellkostenfunktionen:
def sigmoid(z):
return 1 / (1 + np.exp(-z))
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
def compute_gradient_regularized(theta, X, y, lda):
gradient = np.zeros(len(theta))
XT = X.T
beta = sigmoid(X@theta) - y
regterm = lda/len(y) * theta
# theta_0 does not get regularized, so a 0 is substituted in its place
regterm[0] = 0
gradient = (1/len(y) * XT@beta).T + regterm
return gradient
Funktion, die ein Ein-gegen-Alles-Klassifizierungstraining implementiert:
from scipy.optimize import minimize
def train_one_vs_all(X, y, opt_method):
theta_all = np.zeros((y.max()-y.min()+1, X.shape[1]))
for k in range(y.min(),y.max()+1):
grdtruth = np.where(y==k, 1,0)
results = minimize(compute_cost_regularized, theta_all[k-1,:],
args = (X,grdtruth,0.1),
method = opt_method,
jac = compute_gradient_regularized)
# optimized parameters are accessible through the x attribute
theta_optimized = results.x
# Assign thetheta_optimized vector to the appropriate row in the
# theta_all matrix
theta_all[k-1,:] = theta_optimized
return theta_all
Rief die Funktion auf, um das Modell mit verschiedenen Optimierungsmethoden zu trainieren:
theta_all_optimized_cg = train_one_vs_all(X_bias, y, 'CG') # Optimization performed using Conjugate Gradient
theta_all_optimized_bfgs = train_one_vs_all(X_bias, y, 'BFGS') # optimization performed using Broyden–Fletcher–Goldfarb–Shanno
Wir sehen, dass sich die Vorhersageergebnisse je nach verwendetem Algorithmus unterscheiden:
def predict_one_vs_all(X, theta):
return np.mean(np.argmax(sigmoid(X@theta.T), axis=1)+1 == y)*100
In[16]: predict_one_vs_all(X_bias, theta_all_optimized_cg)
Out[16]: 90.319999999999993
In[17]: predict_one_vs_all(X_bias, theta_all_optimized_bfgs)
Out[17]: 96.480000000000004
Jeder, der Daten zum Ausprobieren des Codes erhalten möchte, kann diese in meinem Github finden, wie in diesem Beitrag verlinkt.