Übung 2: Logistische Regression

Übung 2: Logistische Regression

---

einführen

In dieser Übung implementieren Sie die logistische Regression und wenden sie auf zwei verschiedene Datensätze an. Wir werden auch die Robustheit des Algorithmus verbessern, indem wir dem Trainingsalgorithmus eine Regularisierung hinzufügen, und den Modellalgorithmus mit komplexeren Situationen testen.

Bevor Sie mit der Übung beginnen, müssen Sie die folgenden Dateien zum Daten-Upload herunterladen :

• ex2data1.txt – der Trainingsdatensatz für die erste Hälfte
• ex2data2.txt – die zweite Hälfte des Trainingsdatensatzes

Während der gesamten Übung sind folgende Pflichtaufgaben erforderlich :

• Funktionen zum Plotten von 2D-kategorialen Daten ----(3 Punkte)
• Realisieren Sie die Sigmoid-Funktion --------(5 Punkte)
• Implementieren Sie die Kostenfunktion und die Gradientenfunktion der logistischen Regression – (60 Punkte)
• Realisieren Sie die Regressionsvorhersagefunktion --------(5 Punkte)
• Realisieren Sie die reguläre logistische Regressionskostenfunktion ------- (27 Punkte)

1 Logistische Regression

In diesem Teil der Übung erstellen Sie ein logistisches Regressionsmodell, um vorherzusagen, ob ein Student an einer Universität zugelassen wird.

Angenommen, Sie leiten einen Fachbereich an einer Universität und entscheiden anhand der Ergebnisse zweier Prüfungen über die Zulassungschancen jedes Bewerbers. Historische Daten zu früheren Bewerbern sind bereits verfügbar und können als Trainingssatz für die logistische Regression verwendet werden. Für jede Datenzeile sind die beiden Testergebnisse des entsprechenden Bewerbers und das endgültige Zulassungsergebnis enthalten.

In dieser Übung müssen Sie ein Klassifizierungsmodell erstellen, um die Zulassungsergebnisse von Bewerbern basierend auf diesen beiden Testergebnissen vorherzusagen .

1.1 Datenvisualisierung

Bevor Sie mit der Implementierung eines Algorithmusmodells beginnen, ist es am besten, die Daten zunächst zu visualisieren, um die Eigenschaften der Daten intuitiver zu erfassen.

Jetzt müssen Sie den Code schreiben, um die Darstellung der Daten abzuschließen und das unten gezeigte Diagramm anzuzeigen.

Hauptpunkte :

• Importieren Sie die Python-Bibliothek, die verwendet werden muss, ex2data1.txtliest die Daten aus der Datei und zeigt die ersten 5 Zeilen an
• Die xy-Achse zeigt die Ergebnisse der beiden Prüfungen
• Positive und negative Beispiele müssen mit unterschiedlichen Markierungen (verschiedenen Farben) dargestellt werden.

###在这里填入代码###
###主要实现要点1###
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
path = '/home/jovyan/work/ex2data1.txt'
data = pd.read_csv(path,header = None,names=['Exam 1','Exam 2','Admitted'])
data.head()

	Prüfung 1	Prüfung 2	Zugegeben
0	34.623660	78.024693	0
1	30.286711	43.894998	0
2	35.847409	72.902198	0
3	60.182599	86.308552	1
4	79.032736	75.344376	1

###在这里填入代码###
###绘制数据散点图###
positive = data[data['Admitted'].isin([1])]
negative = data[data['Admitted'].isin([0])]
fig, ax = plt.subplots(figsize=(12,8))
# 正向类，绘制50个样本，c=‘b’颜色，maker=‘o’绘制的形状
ax.scatter(positive['Exam 1'], positive['Exam 2'], s=50, c='b', marker='o', label='Admitted')
ax.scatter(negative['Exam 1'], negative['Exam 2'], s=50, c='r', marker='x', label='Not Admitted')
ax.legend()# Legend 图例,获取label标签内容，如图右上角显示
ax.set_xlabel('Exam 1 Score')
ax.set_ylabel('Exam 2 Score')
plt.show()

1.2 Umsetzung

Wie aus dem im vorherigen Teil der Übung gezeichneten Datenverteilungsdiagramm ersichtlich ist, gibt es eine klarere Entscheidungsgrenze zwischen unterschiedlich identifizierten Datenpunkten. Jetzt müssen wir die logistische Regression implementieren und mithilfe der logistischen Regression ein Modell trainieren, um Klassifizierungsergebnisse vorherzusagen.

1.2.1 Sigmoidfunktion

Bevor wir offiziell beginnen, wollen wir zunächst eine Funktion verstehen: die Sigmoid-Funktion .
Wir erinnern uns, dass die Definition der logistischen Regressionsannahme lautet:

Unter diesen stellt g eine häufig verwendete logische Funktion als Sigmoidfunktion dar, und die Formel lautet:

Zusammen erhalten wir die Hypothesenfunktion für das logistische Regressionsmodell:

Als Nächstes müssen Sie Code schreiben, um die Sigmoid-Funktion zu implementieren . Versuchen Sie nach dem Schreiben, einige Werte zu testen. Wenn xder positive Wert von Sigmoid groß ist, sollte der Funktionswert nahe bei 1 liegen. Wenn xder negative Wert von Sigmoid groß ist, sollte der Funktionswert nahe bei 1 liegen Der Funktionswert sollte nahe bei 0 liegen. Und für xgleich 0 beträgt der Funktionswert 0,5.

Stellen Sie sicher, dass nach dem Aufruf der von Ihnen implementierten Sigmoid-Funktion der folgende Code das folgende Bild ausgibt:

###在这里填入代码###
def sigmoid(z):
    
    return 1.0 / (1.0 + np.exp(-z))

###请运行并测试你的代码###
nums = np.arange(-10, 10, step=1)

fig, ax = plt.subplots(figsize=(12,8))
ax.plot(nums, sigmoid(nums), 'r')
plt.show()

1.2.2 Kostenfunktion und Gradient

1.2.2.1 Kostenfunktion

J
$J\left(ich\right)=\frac{}{M}\sum _{ich=1}[-y^{\left(ich\right)}log\left(h_{}\left(x^{\left(i\right)}\right)\right)-\left(1-j^{\left(i\right)}\right)log\left(1-H_{}\left(x^{\left(i\right)}\right)\right)]$

Jetzt müssen Sie Code schreiben, um die Kostenfunktion zur Berechnung der Kosten der logistischen Regression zu implementieren. Nach dem Testen der angegebenen Daten betragen die anfänglichen Kosten etwa 0,693.

Hauptpunkte :

• Implementieren Sie die Kostenfunktion. Die Parameter sind Theta, X, Y.
• Gibt den berechneten Kostenwert zurück.
• Dabei ist Theta ein Parameter, X die Merkmalsspalte im Trainingssatz, y die Beschriftungsspalte im Trainingssatz und alle drei sind Matrizen.

###在这里填入代码###
def cost(theta,X,y):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    first = np.multiply(-y, np.log(sigmoid(X* theta.T)))
    second = np.multiply((1 - y), np.log(1 - sigmoid(X* theta.T)))
    return np.sum(first - second) / (len(X)) 

    

###请运行并测试你的代码###
#增加一列值为1，这和我们在练习1中的操作很相似
data.insert(0, 'Ones', 1)

# 定义X为训练数据，y为目的变量
cols = data.shape[1]
X = data.iloc[:,0:cols-1]
y = data.iloc[:,cols-1:cols]

# 将X,y转换为numpy数组，并初始化theta值为0
X = np.array(X.values)
y = np.array(y.values)
theta = np.zeros(3)

cost(theta, X, y)

0.6931471805599453

1.2.2.2 Gradientenabstieg

Als nächstes müssen wir Code schreiben, um den Gradientenabstieg zu implementieren, um unsere Trainingsdaten, Beschriftungen und einige Parameter θ \theta zu berechnenGradient von$\theta$ .

Hauptpunkte :

• Der Code implementiert die Gradientenfunktion und die Parameter sind Theta, X, Y.
• Gibt den berechneten Gradientenwert zurück.
• Dabei ist Theta ein Parameter, X die Merkmalsspalte im Trainingssatz, y die Beschriftungsspalte im Trainingssatz und alle drei sind Matrizen.

Der Batch-Gradientenabstieg wird in eine vektorisierte Berechnung umgewandelt: $\frac{}{M}{X}^T\left(Sigmoid\right(X\theta )-y)$

$$\frac{\partial J(ich}{\partial {\theta }_{}}=\frac{}{M}\sum _{ich=1}(h_{}\left(x^{\left(i\right)}\right)-j^{\left(i\right)})x_{{}_{}}^{(ich}$$

Beachten Sie hier, dass wir in dieser Funktion keinen tatsächlichen Gradientenabstieg durchführen, sondern nur einen Gradientenschritt berechnen. Da wir Python verwenden, können wir optimizedie Namespaces von SciPy verwenden, um dasselbe zu tun.

###在这里填入代码###
def gradient(theta, X, y):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)

    parameters = int(theta.ravel().shape[1])
    grad = np.zeros(parameters)

    error = sigmoid(X * theta.T) - y

    for i in range(parameters):
        term = np.multiply(error, X[:,i])
        grad[i] = np.sum(term) / len(X)

    return grad

    

###请运行并测试你的代码###
gradient(theta, X, y)

array([ -0.1       , -12.00921659, -11.26284221])

1.2.3 Finden der optimalen Parameter

Das Finden optimaler Parameter kann jetzt mit SciPys Truncated Newton (TNC) implementiert werden.

###请运行并测试你的代码###
import scipy.optimize as opt
result = opt.fmin_tnc(func=cost, x0=theta, fprime=gradient, args=(X, y))
result

(array([-25.16131868,   0.20623159,   0.20147149]), 36, 0)

Sehen wir uns den Wert der Kostenfunktion unter dieser Schlussfolgerung an:

###请运行并测试你的代码###
cost(result[0], X, y)

0.2034977015894744

1.2.4 Auswertung der logistischen Regression

Als nächstes müssen wir Code schreiben, um die Vorhersagefunktion unter Verwendung der gelernten optimalen Parameter $\theta$ , um Vorhersageergebnisse für DatensatzXDiese Funktion kann dann verwendet werden, um die Trainingsgenauigkeit des von uns definierten Klassifikators zu bewerten.

Hypothesenfunktion für die logistische Regression:

$H_{}\left(x\right)=\frac{}{1+e^{-{ich}^{T}X}}$
Dieses $H_{}$Wenn größer oder gleich 0,5, sagen Sie y=1 voraus

Dieses $H_{}$Wenn es weniger als 0,5 beträgt, sagen Sie y=0 voraus.

Hauptpunkte :

• Der Code implementiert die Vorhersagefunktion und die Parameter sind Theta, X.
• Gibt das Vorhersageergebnis zurück, das jeder Datenzeile in X entspricht.
• Dabei ist Theta der Parameter und X die Feature-Spalte im Trainingssatz.

###在这里填入代码###
def predict(theta, X):
    probability = sigmoid(X * theta.T)
    return [1 if x >= 0.5 else 0 for x in probability]
    

###请运行并测试你的代码###
theta_min = np.matrix(result[0])
predict(theta_min, X)

[0,
 0,
 0,
 1,
 1,
 0,
 1,
 0,
 1,
 1,
 1,
 0,
 1,
 1,
 0,
 1,
 0,
 0,
 1,
 1,
 0,
 1,
 0,
 0,
 1,
 1,
 1,
 1,
 0,
 0,
 1,
 1,
 0,
 0,
 0,
 0,
 1,
 1,
 0,
 0,
 1,
 0,
 1,
 1,
 0,
 0,
 1,
 1,
 1,
 1,
 1,
 1,
 1,
 0,
 0,
 0,
 1,
 1,
 1,
 1,
 1,
 0,
 0,
 0,
 0,
 0,
 1,
 0,
 1,
 1,
 0,
 1,
 1,
 1,
 1,
 1,
 1,
 1,
 0,
 1,
 1,
 1,
 1,
 0,
 1,
 1,
 0,
 1,
 1,
 0,
 1,
 1,
 0,
 1,
 1,
 1,
 1,
 1,
 0,
 1]

###请运行并测试你的代码###
predictions = predict(theta_min, X)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))

accuracy = 89%

2 Regularisierte logistische Regression

In diesem Teil der Übung werden wir den logistischen Regressionsalgorithmus verbessern, indem wir einen Regularisierungsterm hinzufügen.

Regularisierung ist ein Begriff in Kostenfunktionen, der dazu führt, dass ein Algorithmus „einfachere“ Modelle bevorzugt. Diese Theorie trägt dazu bei, Überanpassungen zu reduzieren und die Generalisierungsfähigkeit des Modells zu verbessern.

Stellen Sie sich vor, Sie sind Produktionsleiter in einer Fabrik und haben Testergebnisse für einige Chips in zwei Tests. Bei diesen beiden Tests möchten Sie entscheiden, ob der Chip angenommen oder abgelehnt werden soll. Um Ihnen bei dieser schwierigen Entscheidung zu helfen, verfügen Sie über einen Testdatensatz früherer Chips, aus dem Sie ein logistisches Regressionsmodell erstellen können .

2.1 Datenvisualisierung

Ähnlich wie bei der Übung im ersten Teil visualisieren Sie zunächst die Daten:

path =  '/home/jovyan/work/ex2data2.txt'
data2 = pd.read_csv(path, header=None, names=['Test 1', 'Test 2', 'Accepted'])
data2.head()

	Test 1	Test 2	Akzeptiert
0	0,051267	0,69956	1
1	-0,092742	0,68494	1
2	-0,213710	0,69225	1
3	-0,375000	0,50219	1
4	-0,513250	0,46564	1

positive = data2[data2['Accepted'].isin([1])]
negative = data2[data2['Accepted'].isin([0])]

fig, ax = plt.subplots(figsize=(12,8))
ax.scatter(positive['Test 1'], positive['Test 2'], s=50, c='b', marker='o', label='Accepted')
ax.scatter(negative['Test 1'], negative['Test 2'], s=50, c='r', marker='x', label='Rejected')
ax.legend()
ax.set_xlabel('Test 1 Score')
ax.set_ylabel('Test 2 Score')
plt.show()

Für diesen Teil der Daten können wir sehen, dass es keine offensichtliche lineare Entscheidungsgrenze zwischen den Datenpunkten verschiedener Klassen zur Aufteilung der beiden Datenklassen gibt.

Daher kann die logistische Regression bei diesem Datensatz keine gute Leistung erbringen, da die logistische Regression nur lineare Entscheidungsgrenzen kennt.

2.2 Funktionszuordnung

Eine Möglichkeit, die Daten besser anzupassen, besteht darin, Features zu konstruieren, die aus Polynomen der ursprünglichen Features abgeleitet sind, sogenannte Feature-Maps. Wie in der folgenden Abbildung gezeigt, ergeben sich als Ergebnis dieser Abbildung unsere beiden Eigenvektoren $X_{},X_{}$(Ergebnisse aus zwei Qualitätssicherungstests) wurden in einen 28-dimensionalen Vektor umgewandelt.

Ein auf diesem hochdimensionalen Merkmalsvektor trainierter logistischer Regressionsklassifikator verfügt über eine komplexere Entscheidungsgrenze und weist bei der Darstellung in 2D nichtlineare Partitionierungskurven auf.

Obwohl Feature-Maps es uns ermöglichen, einen aussagekräftigeren Klassifikator zu erstellen, ist dieser auch anfälliger für Überanpassung. Als Nächstes müssen Sie eine regulierte logistische Regression implementieren, um die Daten anzupassen, und die Regularisierung verwenden, um bei Überanpassung zu helfen .

Wir beginnen mit der Erstellung einer Reihe von Polynommerkmalen!

# 设定映射深度
degree = 5
# 分别取两次测试的分数
x1 = data2['Test 1']
x2 = data2['Test 2']

data2.insert(3, 'Ones', 1)

# 设定计算方式进行映射
for i in range(1, degree):
    for j in range(0, i):
        data2['F' + str(i) + str(j)] = np.power(x1, i-j) * np.power(x2, j)

# 整理数据列
data2.drop('Test 1', axis=1, inplace=True)
data2.drop('Test 2', axis=1, inplace=True)

print("特征映射后具有特征维数：%d" %data2.shape[1])
data2.head()

特征映射后具有特征维数：12

	Akzeptiert	Einsen	F10	F20	F21	F30	F31	F32	F40	F41	F42	F43
0	1	1	0,051267	0,002628	0,035864	0,000135	0,001839	0,025089	0,000007	0,000094	0,001286	0,017551
1	1	1	-0,092742	0,008601	-0,063523	-0,000798	0,005891	-0,043509	0,000074	-0,000546	0,004035	-0,029801
2	1	1	-0,213710	0,045672	-0,147941	-0,009761	0,031616	-0,102412	0,002086	-0,006757	0,021886	-0,070895
3	1	1	-0,375000	0,140625	-0,188321	-0,052734	0,070620	-0,094573	0,019775	-0,026483	0,035465	-0,047494
4	1	1	-0,513250	0,263426	-0,238990	-0,135203	0,122661	-0,111283	0,069393	-0,062956	0,057116	-0,051818

2.3 Kostenfunktion und Gradient

Als Nächstes müssen Sie Code schreiben, um die Kostenfunktion und den Gradienten der regulierten logistischen Regression zu berechnen und den berechneten Kostenwert und Gradienten zurückzugeben .

J ( θ ) = 1 m ∑ i = 1 m [ − y ( i ) log ⁡ ( h θ ( x ( i ) ) ) − ( 1 − y ( i ) ) log ⁡
$$J\left(ich\right)=\frac{}{M}\sum _{ich=1}[-y^{\left(ich\right)}log\left(h_{}\left(x^{\left(i\right)}\right)\right)-\left(1-j^{\left(i\right)}\right)log\left(1-H_{}\left(x^{\left(i\right)}\right)\right)]+\frac{}{2m}\sum _{j=1}{ich}_J^{}$$

wobei $\lambda$ ist der Parameter „Lernrate“, dessen Wert den Wert des Regularisierungsterms in der Funktion beeinflusst. Und sollte den Parameter θ 0 \theta_0nicht regulieren${ich}_{}$。

###在这里填入代码###
def costReg(theta, X, y, learningRate):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    first = np.multiply(-y, np.log(sigmoid(X * theta.T)))
    second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T)))
    reg = (learningRate / (2 * len(X))) * np.sum(np.power(theta[:,1:theta.shape[1]], 2))
    return np.sum(first - second) / len(X) + reg 

    

Als nächstes müssen wir eine regulierte Gradientenfunktion implementieren , die die Kostenfunktion mithilfe des Gradientenabstiegs minimiert.

Denn bei der Berechnung der Kostenfunktion gilt nicht ${ich}_{}$Aufgrund der Regularisierung wird der Gradientenabstiegsalgorithmus in zwei Fälle unterteilt:

Passen Sie die Aktualisierungsformel an, wenn j=1,2,…,n im obigen Algorithmus:
${ich}_{}:={ich}_{}(1-A\frac{}{M})-A\frac{}{M}\sum _{ich=1}(h_{}\left(x^{\left(i\right)}\right)-j^{\left(i\right)})x_J^{(ich}$

###在这里填入代码###
def gradientReg(theta, X, y, learningRate):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    
    parameters = int(theta.ravel().shape[1])
    grad = np.zeros(parameters)
    
    error = sigmoid(X * theta.T) - y
    
    for i in range(parameters):
        term = np.multiply(error, X[:,i])
        
        if (i == 0):
            grad[i] = np.sum(term) / len(X)
        else:
            grad[i] = (np.sum(term) / len(X)) + ((learningRate / len(X)) * theta[:,i])
    
    return grad

    

Als nächstes initialisieren Sie Variablen ähnlich wie in den Übungen im ersten Teil.

# 从数据集中取得对应的特征列和标签列
cols = data2.shape[1]
X2 = data2.iloc[:,1:cols]
y2 = data2.iloc[:,0:1]

# 转换为Numpy数组并初始化theta为零矩阵
X2 = np.array(X2.values)
y2 = np.array(y2.values)
theta2 = np.zeros(11)

# 设置初始学习率为1，后续可以修改
learningRate = 1

Testen Sie als Nächstes Ihre Implementierung der Kosten- und Gradientenfunktionen mithilfe der initialisierten Variablenwerte.

###请运行并测试你的代码###
costReg(theta2, X2, y2, learningRate)

0.6931471805599454

###请运行并测试你的代码###
gradientReg(theta2, X2, y2, learningRate)

array([0.00847458, 0.01878809, 0.05034464, 0.01150133, 0.01835599,
       0.00732393, 0.00819244, 0.03934862, 0.00223924, 0.01286005,
       0.00309594])

2.4 Finden Sie die optimalen Parameter

Jetzt können wir dieselbe Optimierungsfunktion wie im ersten Teil verwenden, um das optimierte Ergebnis zu berechnen.

result2 = opt.fmin_tnc(func=costReg, x0=theta2, fprime=gradientReg, args=(X2, y2, learningRate))
result2

(array([ 0.53010246,  0.29075567, -1.60725764, -0.58213819,  0.01781027,
        -0.21329507, -0.40024142, -1.3714414 ,  0.02264304, -0.95033581,
         0.0344085 ]), 22, 1)

2.5 Bewertung der regulierten logistischen Regression

Schließlich können wir die Vorhersagefunktion aus Teil 1 verwenden, um zu sehen, wie genau unser Schema anhand der Trainingsdaten ist.

theta_min = np.matrix(result2[0])
predictions = predict(theta_min, X2)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y2)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))

accuracy = 78%