[PYTHON] Essayez d'évaluer les performances du modèle d'apprentissage automatique / de régression

1.Tout d'abord

Cette fois, j'évaluerai les performances du modèle de régression utilisé pour l'apprentissage automatique lors de l'écriture du code.

2. Ensemble de données

L'ensemble de données utilisé est le prix du logement à Boston fourni avec sklearn.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_boston
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression,Ridge
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor,GradientBoostingRegressor
from sklearn.pipeline import Pipeline
from sklearn.metrics import r2_score
from sklearn.model_selection import cross_val_score
from sklearn.utils import shuffle

# --------Charger le jeu de données---------
dataset = load_boston()
X = pd.DataFrame(dataset.data, columns=dataset.feature_names)
y = pd.Series(dataset.target, name='y')
print('X.shape = ', X.shape)
print(X.join(y).head())

Les données sont de 506 au total, la quantité de caractéristiques est de 13 articles et y est le prix cible du logement.

3. Modèle de régression

Il existe cinq modèles de régression utilisés cette fois. Plus tard, nous le rassemblerons sous la forme d'un pipeline pour en faciliter l'utilisation. Les hyperparamètres sont la valeur par défaut.

# ----------Paramètres du pipeline-----------
pipelines = {
  '1.Linear': Pipeline([('std',StandardScaler()),
                        ('est',LinearRegression())]),
     
  '2.Ridge' : Pipeline([('std',StandardScaler()),
                        ('est',Ridge(random_state=0))]),

  '3.Tree'  : Pipeline([('std',StandardScaler()),
                        ('est',DecisionTreeRegressor(random_state=0))]),

  '4.Random': Pipeline([('std',StandardScaler()),
                        ('est',RandomForestRegressor(random_state=0, n_estimators=100))]),  
     
  '5.GBoost': Pipeline([('std',StandardScaler()),
                        ('est',GradientBoostingRegressor(random_state=0))])
}

1.Linear ** Modèle de régression linéaire (linéaire) ** utilisant la méthode des moindres carrés.

2.Ridge Il s'agit d'un ** modèle de régression de crête (Ridge) ** qui supprime le surentraînement en ajoutant des éléments de régression L2 au modèle de régression linéaire.

3.Tree Il s'agit d'un modèle de régression basé sur l '** Arbre de décision **.

4.Random C'est ** Random Forest ** qui crée plusieurs arbres de décision à partir d'entités sélectionnées au hasard et produit en moyenne les prédictions de tous les arbres de décision.

5.GBoost C'est le ** Gradient Boosting ** qui améliore la précision de la prédiction en essayant d'expliquer les informations (résiduelles) que le groupe d'arbres existant ne peut pas expliquer.

4. Indice d'évaluation

Utilisez ** R2_score ** comme index d'erreur. C'est à quel point l'erreur quadratique prévue et mesurée Σ peut être rendue plus petite que l'erreur quadratique moyenne mesurée et mesurée Σ.

Si la prédiction est entièrement en accord avec la mesure réelle, l'indice peut être 1, et si la prédiction est trop mauvaise, l'indice peut être négatif.

5. Méthode Holdout

Tout d'abord, la méthode d'exclusion, qui est une méthode générale pour évaluer les performances d'un modèle, est appliquée. Les performances de généralisation sont examinées en divisant les données en ** données d'entraînement: données de test = 8: 2 **, en entraînement avec les données d'entraînement, puis en évaluant avec des données de test inconnues.

# -----------Méthode Holdout-----------
X_train,X_test,y_train,y_test = train_test_split(X, y, test_size=0.20, random_state=1)  

scores = {}
for pipe_name, pipeline in pipelines.items():
    pipeline.fit(X_train, y_train)
    scores[(pipe_name,'train')] = r2_score(y_train, pipeline.predict(X_train))
    scores[(pipe_name,'test')] = r2_score(y_test, pipeline.predict(X_test))
print(pd.Series(scores).unstack())

À la suite d'une évaluation avec des données de test inconnues, ** 5.GBoost ** était le plus précis (0,924750).

Dans les données d'entraînement, le plus précis (1.0000) ** 3.Tree ** est significativement ramené à (0.821282) dans les données de test, indiquant qu'il est tombé en surentraînement.

** 2.Ridge ** devrait être une version améliorée de ** 1.Linear **, mais les données de test montrent une légère inversion de la précision. En effet, il existe une certaine variation dans la mesure de la précision par la méthode d'exclusion, et nous comparerons les performances plus tard par la méthode plus stricte du pli k.

6. Graphique résiduel

Des tracés résiduels sont créés pour visualiser les performances du modèle. Cela trace les données d'entraînement et les données de test avec ** valeur prédite ** sur l'axe horizontal et ** différence entre la valeur prédite et la valeur réelle ** sur l'axe vertical.

# -------------Graphique résiduel------------
for pipe_name, est in pipelines.items():
    y_train_pred = est.predict(X_train)
    y_test_pred = est.predict(X_test)
    plt.scatter(y_train_pred, y_train_pred - y_train, c = 'blue', alpha=0.5, marker = 'o', label = 'train')
    plt.scatter(y_test_pred, y_test_pred - y_test, c = 'red', marker ='x', label= 'test' )
    plt.hlines(y = 0, xmin = 0, xmax = 50, color = 'black')
    plt.ylim([-20, 20])
    plt.xlabel('Predicted values')
    plt.ylabel('Residuals')        
    plt.title(pipe_name)
    plt.legend()
    plt.show()

En tant que sortie du code, 5 résidus sont tracés de 1.Linear à 5.GBoost, mais ici, seuls 3 typiques sont augmentés.

** Modèle de régression linéaire **. Les données d'entraînement et les données de test ont presque la même variation résiduelle.

** Arbre de décision **. Alors que les données d'entraînement ont un résidu nul complet (précision de 100%), les données de test ont une grande variation résiduelle. C'est un surapprentissage typique.

** Augmentation du gradient **. La variation des résidus est supprimée à la fois dans les données d'apprentissage et les données de test.

7. Méthode k-hold

La ** méthode k-hold ** (vérification d'intersection de division k) permet une évaluation du modèle plus stricte que la méthode holdout.

La procédure spécifique consiste à diviser d'abord les données en k morceaux, à les sélectionner un par un afin de les utiliser comme données de test, et à utiliser les k-1 morceaux restants comme données d'apprentissage.

Ensuite, la méthode ** k-hold ** consiste à s'entraîner avec les données d'entraînement, à répéter la mesure de précision avec les données de test k fois et à prendre la moyenne de la précision obtenue comme précision du modèle. Ici, k = 5 (spécifié par cv = 5).

Notez que ** cross_val_score ** ne mélange pas automatiquement les données comme ** train_test_split **, utilisez donc d'abord l'utilitaire ** shuffle ** pour mélanger les données avant de les traiter.

# -------------- k-méthode de pliage--------------
X_shuffle, y_shuffle =shuffle(X, y, random_state= 1)  #Mélange de données

scores={}
for pipe_name, est in pipelines.items():  
    cv_results = cross_val_score(est, X_shuffle, y_shuffle, cv=5, scoring='r2')    
    scores[(pipe_name,'avg')] = cv_results.mean()
    scores[(pipe_name,'score')] = np.round(cv_results,5)  # np.round est l'ajustement des chiffres
print(pd.Series(scores).unstack())

Les cinq nombres ** score ** inclus entre [] à côté de ** moy ** sont la précision calculée à chaque fois. Si vous regardez ** 1.Linear **, vous pouvez voir qu'il varie de ** minimum 0,64681 à maximum 0,76342 **. En faisant la moyenne de ces nombres, une évaluation stricte du modèle est effectuée.

Vous pouvez voir que ** 2.Ridge ** est légèrement plus précis que ** 1.Linear **.

En fin de compte, le meilleur modèle pour les prix des maisons à Boston était de ** 5 Go **.