Analyse de régression avec Python

Bonjour, c'est Motty. Cette fois, j'ai décrit l'analyse de régression à l'aide de Python.

Régression

L'analyse de régression est une méthode de prédiction des données cibles à l'aide des données disponibles. A ce moment, la structure de la relation quantitative est appliquée aux données (modèle de régression). Si le modèle de régression est une ligne droite, on l'appelle une ligne de régression, et si la fonction d'ordre n est appliquée par régression polypoly, on parle de courbe de régression.

Comment déterminer le modèle

La méthode des moindres carrés est utilisée pour évaluer le modèle ajusté. L'invention concerne un procédé de sélection d'un coefficient qui minimise la somme des carrés des résidus lors de l'approximation des données obtenues par mesure avec une fonction telle qu'une ligne droite.

Méthode d'évaluation

Utilisez le coefficient de détermination. Plus ce nombre est élevé, meilleur est l'ajustement du modèle de régression aux données réelles. Si la valeur observée = y et la valeur estimée par la fonction est f, elle est exprimée par l'équation suivante.

Si le modèle correspond parfaitement aux données, la valeur du facteur de décision sera 1.

Revenir

Pour les données avec du bruit ajouté à chacune des fonctions linéaires, quadratiques et cubiques J'ai appliqué une ligne de régression.

LinearRegression.py

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

#sklearn
from sklearn.linear_model import LinearRegression as reg
from sklearn.metrics import r2_score

#Liés aux données
CI =["black","red","blue","yellow","green","orange","purple","skyblue"]#ColorIndex

N = 30 #Le nombre d'échantillons
x = np.linspace(1,10,N)
y1 = x *5 + np.random.randn(N)*5
y2 =  2*(x-2)*(x-7) +   np.random.randn(N)*5
y3 =  3*(x-1)*(x-4)*(x-7) +  np.random.randn(N)*10

x = x.reshape([-1,1])
y1 = y1.reshape([-1,1])
y2 = y2.reshape([-1,1])
y3 = y3.reshape([-1,1])

#Apprentissage
clf1, clf2, clf3 = reg(),reg(),reg()
clf1.fit(x,y1),clf2.fit(x,y2),clf3.fit(x,y3)

#x Valeur prévue pour les données
y1_pred,y2_pred,y3_pred = clf1.predict(x),clf2.predict(x),clf3.predict(x)

#dessin
fig = plt.figure(figsize = (15,15))
ax1,ax2,ax3 = fig.add_subplot(3,3,1),fig.add_subplot(3,3,2),fig.add_subplot(3,3,3)
#Data
ax1.scatter(x,y1,c = CI[1],label = "R^2 = {}".format(r2_score(y1,y1_pred)))
ax2.scatter(x,y2,c = CI[2],label = "R^2 = {}".format(r2_score(y2,y2_pred)))
ax3.scatter(x,y3,c = CI[3],label = "R^2 = {}".format(r2_score(y3,y3_pred)))
ax1.legend(),ax2.legend(),ax3.legend()
#Retour en ligne droite
ax1.plot(x,clf1.predict(x), c = CI[0])
ax2.plot(x,clf2.predict(x), c = CI[0])
ax3.plot(x,clf3.predict(x), c = CI[0])

fig.suptitle("RinearLegression", fontsize = 15)
ax1.set_title("1")
ax2.set_title("2")
ax3.set_title("3")

Sans surprise, les résultats montrent que l'ajustement de ligne droite est le meilleur pour les fonctions linéaires.

Régression polymérique

Il peut être approprié d'appliquer une courbe de régression telle qu'une fonction multi-ordre à un ensemble de données tel que 2 ou 3.

polynomial.py

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.linear_model import LinearRegression as reg
from sklearn.metrics import r2_score
from sklearn.preprocessing import PolynomialFeatures as PF


#Liés aux données
CI =["black","red","blue","yellow","green","orange","purple","skyblue"]#ColorIndex
N = 10 #Le nombre d'échantillons
x = np.linspace(1,10,N)
y3 =  3*(x-1)*(x-4)*(x-7) +  np.random.randn(N)*10
x = x.reshape([-1,1])
y3 = y3.reshape([-1,1])


#Apprentissage
clf = reg()
clf.fit(x,y3)
#Commande
DegreeSet =[1,2,3] 
for dg in DegreeSet:
    
    pf = PF(degree = dg, include_bias = False)
    x_poly = pf.fit_transform(x)
    poly_reg = reg()
    poly_reg.fit(x_poly,y3)
    polypred = poly_reg.predict(x_poly)

    #x Valeur prévue pour les données
    pred = clf.predict(x)
    #dessin
    plt.scatter(x,y3,c = CI[dg], label = "R^2={}".format(r2_score(y3,polypred)))
    plt.plot(x, polypred,c = CI[0])
    plt.legend()
    plt.title("Regression")
    plt.show()

En conséquence, le modèle s'adapte bien et le coefficient de détermination est élevé chaque fois que l'ordre est augmenté à 1, 2 et 3.

Dois-je augmenter la commande?

Plus l'ordre est élevé, plus le modèle devient expressif et mieux il s'intègre dans les données, mais plus l'ordre est élevé, plus les performances de généralisation (surapprentissage) sont faibles. Pour résoudre un tel problème, il est conseillé d'utiliser une simple régression linéaire, AIC, ou d'autres pénalités.

(Lorsque nous avons réduit l'ajustement des données au modèle au problème de minimisation AIC Comme vous pouvez le voir dans la formule, des pénalités sont fixées pour l'augmentation dans l'ordre, et l'ordre optimal peut être sélectionné. )

Comme sklearn n'avait pas la bonne bibliothèque, je prévois d'évaluer le modèle en utilisant ma propre AIC dans le prolongement de cela.