Dernière fois Cours d'apprentissage automatique à l'Université de Tsukuba: étudier sklearn tout en intégrant le script Python au devoir (15) https://github.com/legacyworld/sklearn-basic

Défi 7.3 Comparaison de la méthode du gradient et de la méthode de Newton en régression logistique

Commentaire sur Youtube: 8e (1) toutes les 27 minutes Je n'ai pas pu obtenir le résultat expliqué dans la conférence, probablement parce que la mise en œuvre de la méthode re-deep était mauvaise. Je l'ai essayé avec une régression de crête, etc., mais le résultat n'a pas beaucoup changé.

Mathématiquement, il implémente ce qui suit:

La méthode de descente la plus raide

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)

Dans les données d'iris, $ N = 150 $, $ w $ correspond à 5 dimensions en ajoutant des sections La raison pour laquelle $ E (w) $ est divisé par $ N $ est que le coût initial ne correspond pas à moins que cela ne soit fait. Cependant, même avec cela, seulement 0,1 a divergé, et à part cela, il a convergé correctement. Je pense que quelque chose ne va pas, mais je ne suis pas sûr.

Méthode Newton

\nabla \nabla E(w) = X^TRX\,,R=\hat{t}_n(1-\hat{t}_n)Matrice diagonale de\\
w \leftarrow w-(X^TRX)^{-1}X^T(\hat{t}-t)

La méthode Newton est généralement correcte, mais malheureusement le coût final est assez différent. Il est également difficile de comprendre que seuls trois poids sont affichés dans les résultats de la conférence.

Cliquez ici pour le code source Puisque le code source de l'exercice 4.3 est détourné, il est classé par BaseEstimator, mais il n'y a pas de signification.

`python:Homework_7.3.py`


#Défi 7.3 Comparaison de la méthode du gradient et de la méthode de Newton en régression logistique
#Commentaire sur Youtube: 8e(1)Par 27 minutes
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
        #Types de fonctionnalités
        dim = X.T.shape[1]
        #Valeur initiale de la version bêta
        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)))
            #La méthode de descente la plus raide
            if f == "GD":
                beta = beta - eta*np.dot(X,(t_hat-y).reshape(-1,1))
            #Méthode Newton
            else:
                #Matrice diagonale de NxN
                R = np.diag((t_hat*(1-t_hat))[0])
                #Procession de Hesse
                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)))

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

#Considérez simplement si virginica ou non
target = 2
X = iris.data
y = iris.target
# y =Pas 2(Pas virginica)Si 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 #Ajouter 1 à la première colonne
epsilon = 10 ** (-8)
#La méthode de descente la plus raide
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 ")

#Méthode Newton
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 ")

#Résultats de la régression logistique de 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_}")

Résultats de la méthode de descente la plus raide

Dans la conférence, le paramètre de pas a divergé jusqu'à 0,003 et est devenu le minimum à 0,002, mais le résultat était complètement différent. 7.3GD.png

Résultats de la méthode Newton

Le coût final est inférieur d'un chiffre, mais le nombre de fois est à peu près le même que celui de la conférence. Cela ne semble pas si mal. 7.3Newton.png

Résultats de la régression logistique de sklearn

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

résultat

Les paramètres obtenus sont les suivants La méthode de plongée est le résultat lorsque le coût final est la plus petite taille de pas = 0,01

La méthode de descente la plus raide:(w_0,w_1,w_2,w_3,w_4) = (-18.73438888,-1.97839772,-2.69938233,15.54339092,12.96694841)\\
Méthode Newton:(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)

La méthode de Newton est certes rapide, mais elle nécessite un calcul de matrice inverse, donc si le nombre de dimensions ou le nombre d'échantillons augmente, finira-t-il par s'installer dans la méthode stochastique re-soudaine?

Messages passés

Cours d'apprentissage automatique à l'Université de Tsukuba: Étudiez sklearn tout en intégrant le script Python à la tâche (16)