Ich habe ein Tutorial verfolgt, um logistische Gradientenabstieg in Python zu implementieren. Hier
ist der Link: http://www.johnwittenauer.net/machine-learning-exercises-in-python-part-3/
Seine ipython Notebook Github für diese especific Übung hier:
https://github.com/jdwittenauer/ipython-notebooks/blob/master/notebooks/ml/ML-Exercise2.ipynb
Hier ist mein Code für dieses Problem:
Logistischer Gradient Abstieg konvergiert nicht in Python fmin_tnc
import pandas as pd
import matplotlib.pylab as plt
import numpy as np
import scipy.optimize as opt
def sigmoid(Z):
'''Compute the sigmoid function '''
return 1.0/(1.0 + np.exp(-1.0 * Z))
###########################################
def compute_cost(theta,X,y, learningRate):
'''compute cost given '''
theta = np.matrix(theta)
X = np.matrix(X)
y = np.matrix(y)
m = y.size
theta0 = np.zeros((1,X.shape[1]))
theta0[0,1:] = theta[0,1:]
reg = np.dot((learningRate/2*m),(theta0.T.dot(theta0)))
Z = X.dot(theta.T)
hypothesis = sigmoid(Z)
exp1 = (-y.T.dot(np.log(hypothesis)))
exp2 = ((1.0 - y).T.dot(np.log(1.0 - hypothesis)))
J = (exp1 - exp2).dot(1/m)
return J.sum() + reg.sum()
def grad(theta,X,y,learningRate):
theta = theta.T
X = np.matrix(X)
y = np.matrix(y)
m = y.shape[0]
theta0 = np.zeros(X.shape[1])
theta0[1:] = theta[1:]
theta = np.matrix(theta)
theta0 = np.matrix(theta0)
reg = np.dot(learningRate/m, theta)
Z = X.dot(theta.T)
hypothesis = sigmoid(Z)
error = hypothesis - y
grad = np.dot((X.T.dot(error).flatten()),1/m) + reg
grad= grad.flatten()
grad
##
def predict(theta, X):
probability = sigmoid(X * theta.T)
return [1 if (x >= 0.5) else 0 for x in probability]
Hier heißt der Code:
Daten2 = pd.read_csv ('ex2data2.txt', header = None, names = [ 'Test 1', 'Test 2', 'Akzeptiert'])
y = data2[data2.columns[-1]].as_matrix()
m = len(y)
y = y.reshape(m, 1)
X = data2[data2.columns[:-1]]
X = X.as_matrix()
_lambda = 1
from sklearn.preprocessing import PolynomialFeatures
#Get all high order parameters
feature_mapper = PolynomialFeatures(degree=6)
X = feature_mapper.fit_transform(X)
# convert to numpy arrays and initalize the parameter array theta
theta = np.zeros(X.shape[1])
learningRate = 1
compute_cost(theta, X, y, learningRate)
result = opt.fmin_tnc(func=compute_cost,x0=theta,fprime=grad,args= (X,y,learningRate))
Für eine Variable alles geklappt hat, aber mit mehr Funktionen (Übung 2) hat es nicht gut funktioniert. Alles bis zur Verwendung der optimierten Gradientenabstiegsfunktion (fmin_tnc) war exakt gleich.
Irgendwie konvergiert sogar sein Code nicht zum erwarteten Wert. Er ist es sein Blog Beispiel zeigt, was man für das Ergebnis fmin_tnc
sein, aber wenn Sie bei jedem Schritt seines Code folgen Sie folgendes Ergebnis: 
Nun, wie Sie können Sehen Sie, es ist ein bisschen anders. Aber ich habe eine andere Sache in seinem Code entdeckt. Er ließ 2 Spalten "Test 1" und "Test 2" fallen und behielt nur die Parameter hoher Ordnung. Das fühlt sich komisch an, denn in Andrew Ngs Lösung lässt er keine Spalte des Tisches fallen, aber er benutzt 28 Funktionen. Dieser verwendet nur 11 Funktionen. Ich habe andere Codes gefunden und wollte, dass meine Funktion cost_function und gradient funktioniert. Ich glaube, dass sie an einem lokalen Minimum hängen bleiben und nicht konvergieren.
Mein letzter Versuch habe ich mit allen 28 Features gemacht, genau wie Andrew's dataFrame. Leider habe ich ein anderes Ergebnis bekam, wie Sie unten sehen können:
Wie Sie sehen können, habe ich eine höhere Genauigkeit bekam aber meine Kosten bleibt höher als die erwartete, nämlich: 0,52900
Meine Absicht ist es nicht, die Codequalität des Blogs zu verringern. Ich folge immer noch seinen Schritten auf anderen Tutorials und scheint eine gute Quelle zu sein.
Unten ist ein Link zu meinem Code, ich benutze fmin_tnc genau so, wie er es macht. Ich habe gerade eine stärker vektorisierte gradient_function erstellt. Der Name der Datei ist Regression Logistic Regularized.py
Github: https://github.com/vinipachecov/Machine-Learning/tree/master/Logistic%20Regression