Letztes Mal Kurs für maschinelles Lernen an der Tsukuba University: Lernen Sie sklearn, während Sie das Python-Skript in die Aufgabe aufnehmen (15) https://github.com/legacyworld/sklearn-basic

Herausforderung 7.3 Vergleich der Gradientenmethode und der Newton-Methode in der logistischen Regression

Kommentar auf Youtube: 8. (1) pro 27 Minuten Ich konnte das Ergebnis in der Vorlesung nicht erklären lassen, wahrscheinlich weil die Implementierung der Re-Deep-Methode schlecht war. Ich habe es mit Ridge Regression usw. versucht, aber das Ergebnis hat sich nicht viel geändert.

Mathematisch implementiert es Folgendes:

Die steilste Abstiegsmethode

E(w) = -\frac{1}{N}\sum_{n=1}^{N}{t_n\,\log\hat t_n + (1-t_n)\,\log(1-\hat t_n)}\\
\frac{\partial E(w)}{\partial w} = X^T(\hat t-t) \\
w \leftarrow w - \eta X^T(\hat t-t)

In Irisdaten ist $ N = 150 $, $ w $ 5 Dimensionen, indem Abschnitte hinzugefügt werden Der Grund, warum $ E (w) $ durch $ N $ geteilt wird, ist, dass die anfänglichen Kosten nicht übereinstimmen, wenn dies nicht getan wird. Trotzdem divergierten nur 0,1, und ansonsten konvergierte es richtig. Ich denke, etwas stimmt nicht, bin mir aber nicht sicher.

Newton-Methode

\nabla \nabla E(w) = X^TRX\,,R=\hat{t}_n(1-\hat{t}_n)Diagonale Matrix von\\
w \leftarrow w-(X^TRX)^{-1}X^T(\hat{t}-t)

Die Newton-Methode ist im Allgemeinen korrekt, aber leider sind die Endkosten ganz anders. Es ist auch schwer zu verstehen, dass in den Ergebnissen der Vorlesung nur drei Gewichte angezeigt werden.

Klicken Sie hier für den Quellcode Da der Quellcode von Übung 4.3 umgeleitet wird, wird er von BaseEstimator klassifiziert, hat dort jedoch keine Bedeutung.

`python:Homework_7.3.py`


#Herausforderung 7.3 Vergleich der Gradientenmethode und der Newton-Methode in der logistischen Regression
#Kommentar auf Youtube: 8 ..(1)Pro 27 Minuten
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import preprocessing,metrics
from sklearn.linear_model import LogisticRegression
from sklearn.base import BaseEstimator
import statsmodels.api as sm
from sklearn.datasets import load_iris  
iris = load_iris()

class MyEstimator(BaseEstimator):
    def __init__(self,ep,eta):
        self.ep = ep
        self.eta = eta
        self.loss = []

    def fit(self, X, y,f):
        m = len(y)
        loss = []
        diff = 10**(10)
        ep = self.ep
        #Arten von Funktionen
        dim = X.T.shape[1]
        #Anfangswert von Beta
        beta = np.zeros(dim).reshape(-1,1)
        eta = self.eta
        
        while abs(diff) > ep:
            t_hat = self.sigmoid(beta.T,X)
            loss.append(-(1/m)*np.sum(y*np.log(t_hat) + (1-y)*np.log(1-t_hat)))
            #Die steilste Abstiegsmethode
            if f == "GD":
                beta = beta - eta*np.dot(X,(t_hat-y).reshape(-1,1))
            #Newton-Methode
            else:
                #Diagonale Matrix von NxN
                R = np.diag((t_hat*(1-t_hat))[0])
                #Hessen Prozession
                H = np.dot(np.dot(X,R),X.T)
                beta = beta - np.dot(np.linalg.inv(H),np.dot(X,(t_hat-y).reshape(-1,1)))
            if len(loss) > 1:
                diff = loss[len(loss)-1] - loss[len(loss)-2]
                if diff > 0:
                    break
        self.loss = loss
        self.coef_ = beta
        return self

    def sigmoid(self,w,x):
        return 1/(1+np.exp(-np.dot(w,x)))

#Graph
fig = plt.figure(figsize=(20,10))
ax = [fig.add_subplot(3,3,i+1) for i in range(9)]

#Überlegen Sie einfach, ob virginica oder nicht
target = 2
X = iris.data
y = iris.target
# y =Nicht 2(Nicht virginica)Wenn 0
y[np.where(np.not_equal(y,target))] = 0
y[np.where(np.equal(y,target))] = 1
scaler = preprocessing.StandardScaler()
X_fit = scaler.fit_transform(X)
X_fit = sm.add_constant(X_fit).T #Fügen Sie 1 zur ersten Spalte hinzu
epsilon = 10 ** (-8)
#Die steilste Abstiegsmethode
eta_list = [0.1,0.01,0.008,0.006,0.004,0.003,0.002,0.001,0.0005]
for index,eta in enumerate(eta_list):
    myest = MyEstimator(epsilon,eta)
    myest.fit(X_fit,y,"GD")
    ax[index].plot(myest.loss)
    ax[index].set_title(f"Optimization with Gradient Descent\nStepsize = {eta}\nIterations:{len(myest.loss)}; Initial Cost is:{myest.loss[0]:.3f}; Final Cost is:{myest.loss[-1]:.6f}")
plt.tight_layout()    
plt.savefig(f"7.3GD.png ")

#Newton-Methode
myest.fit(X_fit,y,"newton")
plt.clf()
plt.plot(myest.loss) 
plt.title(f"Optimization with Newton Method\nInitial Cost is:{myest.loss[0]:.3f}; Final Cost is:{myest.loss[-1]:.6f}")
plt.savefig("7.3Newton.png ")

#Ergebnisse der logistischen Regression von sklearn
X_fit = scaler.fit_transform(X)
clf = LogisticRegression(penalty='none')
clf.fit(X_fit,y)
print(f"accuracy_score = {metrics.accuracy_score(clf.predict(X_fit),y)}")
print(f"coef = {clf.coef_} intercept = {clf.intercept_}")

Ergebnisse der steilsten Abstiegsmethode

In der Vorlesung ging der Schrittparameter bis zu 0,003 auseinander und wurde bei 0,002 zum Minimum, aber das Ergebnis war völlig anders. 7.3GD.png

Ergebnisse der Newton-Methode

Die endgültigen Kosten sind eine Ziffer kleiner, aber die Häufigkeit entspricht in etwa der Vorlesung. Es scheint nicht so falsch. 7.3Newton.png

Ergebnisse der Logistik-Regression von sklearn

accuracy_score = 0.9866666666666667
coef = [[-2.03446841 -2.90222851 16.58947002 13.89172352]] intercept = [-20.10133936]

Ergebnis

Die erhaltenen Parameter sind wie folgt Die Wiederholungsmethode ist das Ergebnis, wenn die Endkosten die kleinste Schrittgröße = 0,01 sind

Die steilste Abstiegsmethode:(w_0,w_1,w_2,w_3,w_4) = (-18.73438888,-1.97839772,-2.69938233,15.54339092,12.96694841)\\
Newton-Methode:(w_0,w_1,w_2,w_3,w_4) = (-20.1018028,-2.03454941,-2.90225059,16.59009858,13.89184339)\\
sklearn:(w_0,w_1,w_2,w_3,w_4) = (-20.10133936,-2.03446841,-2.90222851,16.58947002,13.89172352)

Die Newton-Methode ist sicherlich schnell, aber die Berechnung der inversen Matrix ist unerlässlich. Wenn also die Anzahl der Dimensionen oder die Anzahl der Proben zunimmt, wird sie sich schließlich in der stochastischen Methode für plötzliche Wiederholungen niederlassen?

Frühere Beiträge

Kurs für maschinelles Lernen an der Tsukuba-Universität: Lernen Sie sklearn, während Sie das Python-Skript zu einem Teil der Aufgabe machen (16).