[PYTHON] J'ai essayé d'implémenter diverses méthodes d'apprentissage automatique (modèle de prédiction) en utilisant scicit-learn
- Articles envoyés par des data scientists de l'industrie manufacturière
- Cette fois, nous avons implémenté et organisé divers modèles de prédiction à l'aide de scikit-learn.
introduction
Cette fois, j'ai implémenté un modèle de prédiction pour l'apprentissage automatique à l'aide de scicit-learn. J'ai également résumé les points lors de l'utilisation de chaque méthode.
Une série d'étapes pour construire un modèle prédictif
Le flux de construction d'un modèle de prédiction est résumé ci-dessous. Il y a des choses importantes dans chaque phase, mais les détails seront organisés séparément.
(1) Organisation des problèmes: clarifier les problèmes commerciaux à résoudre (2) Collecte de données: organiser les données disponibles et évaluer si l'objectif peut être atteint. (3) Tabulation de base des données: Visualisez les caractéristiques des données à analyser et analysez ensemble la tabulation de base. (4) Prétraitement des données: nettoyez les données en éliminant la poussière cachée dans les données (5) Extraction de la quantité de fonctionnalités: supprimez la quantité de fonctionnalités inutiles et n'utilisez que les variables explicatives nécessaires (6) Normalisation des données: normaliser les données pour qu'elles correspondent à l'échelle de la quantité de caractéristiques (7) Sélection de la méthode: Sélectionnez une méthode appropriée en fonction des données (8) Apprentissage du modèle: Apprentissage des règles de données par la méthode sélectionnée (9) Vérification / évaluation du modèle: confirmer l'exactitude de la prédiction de la méthode apprise et évaluer la validité du modèle.
À propos de scikit-learn
scikit-learn est une bibliothèque d'apprentissage automatique Python.
Collecte de données
Cette fois, nous allons construire un modèle de prévision en utilisant les données de prix des logements à Boston publiées dans le référentiel UCI Machine Learning.
| article | Aperçu |
|---|---|
| base de données | ・ Maison de Boston-price |
| nombre d'échantillons | ・ 506 pièces |
| Le nombre de colonnes | ・ 14 pièces |
Le code python est ci-dessous.
#Importer les bibliothèques requises
import pandas as pd
import numpy as np
from sklearn.datasets import load_boston
#Lire l'ensemble de données
boston = load_boston()
#Créer un bloc de données
#Stockage des variables explicatives
df = pd.DataFrame(boston.data, columns = boston.feature_names)
#Ajouter une variable objective
df['MEDV'] = boston.target
#Vérifiez le contenu des données
df.head()
L'explication de chaque nom de colonne est omise. ・ Variables explicatives: 13 ・ Variable objectif: 1 (MEDV)
Agrégation de base des données
Puisqu'il y a 13 variables explicatives cette fois, nous utiliserons un diagramme de relations multivariées pour voir efficacement les relations entre chaque variable explicative et variable objective. Cette fois, j'aimerais utiliser une bibliothèque appelée seaborn pour la visualisation. Commencez par créer un diagramme de relations à plusieurs variables.
#Importer les bibliothèques requises
import seaborn as sns
#Diagramme de corrélation multivariée
sns.pairplot(df, size=1.0)
À première vue, RM (nombre moyen de pièces par logement) et MEDV (prix du logement) semblent avoir une corrélation positive. Je vais l'analyser un peu plus en détail même si je le réduis à deux.
#Relation entre RM (nombre moyen de pièces par logement) et MEDV (prix du logement)
sns.regplot('RM','MEDV',data = df)
En regardant la relation en détail comme celle-ci, il semble qu'il y ait une corrélation entre RM (nombre moyen de pièces par logement) et MEDV (prix du logement).
Ensuite, je voudrais trouver la matrice des coefficients de corrélation.
#Calculer la matrice des coefficients de corrélation
df.corr()
Prétraitement des données
Lors du prétraitement, il est nécessaire d'éliminer les poussières (valeurs aberrantes, aberrantes, manquantes) cachées dans les données. Le prétraitement est important dans l'analyse des données, mais cette fois, nous ne vérifierons que les valeurs manquantes.
#Confirmation des valeurs manquantes
df.isnull().sum()
CRIM 0
ZN 0
INDUS 0
CHAS 0
NOX 0
RM 0
AGE 0
DIS 0
RAD 0
TAX 0
PTRATIO 0
B 0
LSTAT 0
MEDV 0
dtype: int64
Puisqu'il n'y a aucune valeur manquante dans les données de prix des maisons de Boston, nous l'analyserons tel quel.
Normalisation des données
Cette fois, l'ingénierie de la quantité d'entités est exclue (cela devrait en fait être fait). Ensuite, lors de la construction du modèle de régression linéaire, les données sont divisées en données d'apprentissage et données d'évaluation. Après cela, la normalisation est effectuée pour correspondre à l'échelle des variables explicatives.
#Importation de bibliothèque
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
#Créer des données d'entraînement et des données d'évaluation
x_train, x_test, y_train, y_test = train_test_split(df.iloc[:, 0:13], df.iloc[:, 13],
test_size=0.2, random_state=1)
#Standardiser les données
sc = StandardScaler()
sc.fit(x_train) #Standardisé avec les données d'entraînement
x_train_std = sc.transform(x_train)
x_test_std = sc.transform(x_test)
Une fois cela fait, nous sélectionnerons la méthode et construirons le modèle de prédiction. Cette fois, j'ai décidé de mettre en œuvre la méthode suivante.
- Régression linéaire (régression multiple)
- Régression Ridge
- Régression par lasso
- Régression Elastic Net
- Retour aléatoire dans la forêt
- GBDT (arbre d'amplification de gradient)
- SVR (Support Vector Machine)
1. À propos de la régression linéaire
La formule générale de prédiction de la régression linéaire est la suivante.
\begin{eqnarray}
y = \sum_{i=1}^{n}(w_{i}x_{i})+b=w_{1}x_{1}+w_{2}x_{2}+・ ・ ・+w_{n}x_{n}+b
\end{eqnarray}
$ w_i $: Poids de la variable explicative $ x_i $ (coefficient de retour) $ b $: Biais (section)
#Importation de bibliothèque
from sklearn.linear_model import LinearRegression
#Bibliothèque pour le calcul des scores
from sklearn.metrics import r2_score
from sklearn.metrics import mean_absolute_error
#Apprentissage de modèle
lr = LinearRegression()
lr.fit(x_train_std, y_train)
#Prévoir
pred_lr = lr.predict(x_test_std)
#Évaluation
#Coefficient de décision(R2)
r2_lr = r2_score(y_test, pred_lr)
#Erreur absolue moyenne(MAE)
mae_lr = mean_absolute_error(y_test, pred_lr)
print("R2 : %.3f" % r2_lr)
print("MAE : %.3f" % mae_lr)
#Coefficient de régression
print("Coef = ", lr.coef_)
#Section
print("Intercept =", lr.intercept_)
Le résultat de sortie est le suivant.
R2 : 0.779
MAE : 3.113
Coef = [-0.93451207 0.85487686 -0.10446819 0.81541757 -1.90731862 2.54650028
0.25941464 -2.92654009 2.80505451 -1.95699832 -2.15881929 1.09153332
-3.91941941]
Intercept = 22.44133663366339
Il n'est pas bon de juger uniquement par la valeur numérique de l'indice d'évaluation, je vais donc essayer d'afficher la valeur prédite et la valeur mesurée dans un nuage de points.
#Importation de bibliothèque
import matplotlib.pyplot as plt
%matplotlib inline
plt.xlabel("pred_lr")
plt.ylabel("y_test")
plt.scatter(pred_lr, y_test)
plt.show()
En regardant ce résultat, je ne pense pas que nous ayons fait une telle prédiction étrange. En fait, nous allons étudier en détail ici pour améliorer la précision, mais cette fois, nous allons essayer une autre méthode.
2. À propos de la régression Ridge
La régression Ridge est la fonction de perte de la régression linéaire avec un terme de régularisation. La fonction de perte de la régression linéaire est la suivante.
\begin{eqnarray}
L = (\boldsymbol{y} - X\boldsymbol{w})^{T}(\boldsymbol{y}-X\boldsymbol{w})
\end{eqnarray}
$ \ boldsymbol {y} $: valeur mesurée vectorisée de la variable objectif $ \ boldsymbol {w} $: coefficient de régression vectorisé $ X $: Une matrice de valeurs mesurées de $ n $ nombre d'échantillons et $ m $ nombre de variables explicatives
Dans la régression Ridge, la fonction de perte change comme suit.
\begin{eqnarray}
L = (\boldsymbol{y} - X\boldsymbol{w})^{T}(\boldsymbol{y}-X\boldsymbol{w}) + λ||\boldsymbol{w}||_{2}^{2}
\end{eqnarray}
La régression Ridge la rend régulière en ajoutant le carré de la norme L2 du poids $ \ boldsymbol {w} $ comme décrit ci-dessus.
Le code python est ci-dessous. C'est facile avec scikit-learn.
#Importation de bibliothèque
from sklearn.linear_model import Ridge
#Apprentissage de modèle
ridge = Ridge(alpha=10)
ridge.fit(x_train_std, y_train)
#Prévoir
pred_ridge = ridge.predict(x_test_std)
#Évaluation
#Coefficient de décision(R2)
r2_ridge = r2_score(y_test, pred_ridge)
#Erreur absolue moyenne(MAE)
mae_ridge = mean_absolute_error(y_test, pred_ridge)
print("R2 : %.3f" % r2_ridge)
print("MAE : %.3f" % mae_ridge)
#Coefficient de régression
print("Coef = ", ridge.coef_)
Le paramètre de régularisation est défini de manière appropriée (la valeur par défaut de scikit-learn est alpha = 1.0) Le résultat de sortie est le suivant.
R2 : 0.780
MAE : 3.093
Coef = [-0.86329633 0.7285083 -0.27135102 0.85108307 -1.63780795 2.6270911
0.18222203 -2.64613645 2.17038535 -1.42056563 -2.05032997 1.07266175
-3.76668388]
Je voudrais afficher la valeur prédite et la valeur mesurée dans un diagramme de dispersion.
plt.xlabel("pred_ridge")
plt.ylabel("y_test")
plt.scatter(pred_ridge, y_test)
plt.show()
Ce n'est pas très différent de la régression linéaire car nous n'avons pas réglé ni sélectionné de paramètres.
3. À propos de la régression Lasso
La partie terme de régularisation est différente entre la régression Lasso et la régression Ridge. Dans la régression Lasso, la fonction de perte change comme suit.
\begin{eqnarray}
L = \frac{1}{2}(\boldsymbol{y} - X\boldsymbol{w})^{T}(\boldsymbol{y}-X\boldsymbol{w}) + λ||\boldsymbol{w}||_{1}
\end{eqnarray}
La régression Lasso diffère de la régression Ridge en ce que le terme de régularisation est la norme L1. Je vais omettre les détails cette fois.
Le code python est ci-dessous.
#Importation de bibliothèque
from sklearn.linear_model import Lasso
#Apprentissage de modèle
lasso = Lasso(alpha=0.05)
lasso.fit(x_train_std, y_train)
#Prévoir
pred_lasso = lasso.predict(x_test_std)
#Évaluation
#Coefficient de décision(R2)
r2_lasso = r2_score(y_test, pred_lasso)
#Erreur absolue moyenne(MAE)
mae_lasso = mean_absolute_error(y_test, pred_lasso)
print("R2 : %.3f" % r2_lasso)
print("MAE : %.3f" % mae_lasso)
#Coefficient de régression
print("Coef = ", lasso.coef_)
Le paramètre de régularisation est défini de manière appropriée (la valeur par défaut de scikit-learn est alpha = 1.0) Le résultat de sortie est le suivant.
R2 : 0.782
MAE : 3.071
Coef = [-0.80179157 0.66308749 -0.144492 0.81447322 -1.61462819 2.63721307
0.05772041 -2.64430158 2.11051544 -1.40028941 -2.06766744 1.04882786
-3.85778379]
Je voudrais afficher la valeur prédite et la valeur mesurée dans un diagramme de dispersion.
plt.xlabel("pred_lasso")
plt.ylabel("y_test")
plt.scatter(pred_lasso, y_test)
plt.show()
La régression au lasso ne change pas grand-chose non plus.
4. À propos de la régression ElasticNet
C'est une méthode qui combine la régression ElasticNet, la régularisation L1 et la régularisation L2.
Le code python est ci-dessous.
#Importation de bibliothèque
from sklearn.linear_model import ElasticNet
#Apprentissage de modèle
elasticnet = ElasticNet(alpha=0.05)
elasticnet.fit(x_train_std, y_train)
#Prévoir
pred_elasticnet = elasticnet.predict(x_test_std)
#Évaluation
#Coefficient de décision(R2)
r2_elasticnet = r2_score(y_test, pred_elasticnet)
#Erreur absolue moyenne(MAE)
mae_elasticnet = mean_absolute_error(y_test, pred_elasticnet)
print("R2 : %.3f" % r2_elasticnet)
print("MAE : %.3f" % mae_elasticnet)
#Coefficient de régression
print("Coef = ", elasticnet.coef_)
Le paramètre de régularisation est défini de manière appropriée (la valeur par défaut de scikit-learn est alpha = 1.0) Le résultat de sortie est le suivant.
R2 : 0.781
MAE : 3.080
Coef = [-0.80547228 0.64625644 -0.27082019 0.84654972 -1.51126947 2.66279832
0.09096052 -2.51833347 1.89798734 -1.21656705 -2.01097151 1.05199894
-3.73854124]
Je voudrais afficher la valeur prédite et la valeur mesurée dans un diagramme de dispersion.
plt.xlabel("pred_elasticnet")
plt.ylabel("y_test")
plt.scatter(pred_elasticnet, y_test)
plt.show()
La régression ElasticNet n'a pas non plus beaucoup changé.
5. À propos de la régression de forêt aléatoire
Ensuite, nous allons construire un modèle de prédiction pour le système d'arbre de décision. Le premier est la régression Random Forest.
RandomForest est une collection de nombreux arbres de décision différents basés sur la mise en sac de l'apprentissage d'ensemble. L'inconvénient de l'arbre de décision seul est qu'il est facile de surapprendre, mais Random Forest est une façon de traiter ce problème.
Le code python est ci-dessous.
#Importation de bibliothèque
from sklearn.ensemble import RandomForestRegressor
#Apprentissage de modèle
RF = RandomForestRegressor()
RF.fit(x_train_std, y_train)
#Prévoir
pred_RF = RF.predict(x_test_std)
#Évaluation
#Coefficient de décision(R2)
r2_RF = r2_score(y_test, pred_RF)
#Erreur absolue moyenne(MAE)
mae_RF = mean_absolute_error(y_test, pred_RF)
print("R2 : %.3f" % r2_RF)
print("MAE : %.3f" % mae_RF)
#Importance variable
print("feature_importances = ", RF.feature_importances_)
Les paramètres sont laissés à leurs valeurs par défaut. Le résultat de sortie est le suivant.
R2 : 0.899
MAE : 2.122
feature_importances = [0.04563176 0.00106449 0.00575792 0.00071877 0.01683655 0.31050293
0.01897821 0.07745557 0.00452725 0.01415068 0.0167309 0.01329619
0.47434878]
Je voudrais afficher la valeur prédite et la valeur mesurée dans un diagramme de dispersion.
plt.xlabel("pred_RF")
plt.ylabel("y_test")
plt.scatter(pred_RF, y_test)
plt.show()
Sonne mieux que les modèles de système de régression (régression linéaire, régression Ridge, régression Lasso, régression ElasticNet). Je pense qu'il est utile de savoir que RandomForest peut également revenir. De plus, comme RandomForest ne connaît pas le coefficient de régression, nous évaluons la validité du modèle en regardant l'importance des variables.
6. À propos de GBDT (arbre d'amplification de gradient)
Vient ensuite GBDT (gradient boosting tree).
GBDT fait également partie de l'apprentissage d'ensemble, et est un algorithme qui vise à améliorer les performances de généralisation en créant séquentiellement des arbres de décision qui corrigent les erreurs dans certains arbres de décision.
Le code python est ci-dessous.
#Importation de bibliothèque
from sklearn.ensemble import GradientBoostingRegressor
#Apprentissage de modèle
GBDT = GradientBoostingRegressor()
GBDT.fit(x_train_std, y_train)
#Prévoir
pred_GBDT = GBDT.predict(x_test_std)
#Évaluation
#Coefficient de décision(R2)
r2_GBDT = r2_score(y_test, pred_GBDT)
#Erreur absolue moyenne(MAE)
mae_GBDT = mean_absolute_error(y_test, pred_GBDT)
print("R2 : %.3f" % r2_GBDT)
print("MAE : %.3f" % mae_GBDT)
#Importance variable
print("feature_importances = ", GBDT.feature_importances_)
Les paramètres sont laissés à leurs valeurs par défaut. Le résultat de sortie est le suivant.
R2 : 0.905
MAE : 2.097
feature_importances = [0.03411472 0.00042674 0.00241657 0.00070636 0.03040394 0.34353116
0.00627447 0.10042527 0.0014266 0.0165308 0.03114765 0.01129208
0.42130366]
Je voudrais afficher la valeur prédite et la valeur mesurée dans un diagramme de dispersion.
plt.xlabel("pred_GBDT")
plt.ylabel("y_test")
plt.scatter(pred_GBDT, y_test)
plt.show()
C'est la méthode la plus précise à ce jour. Cependant, sachez que GBDT est facile à surapprendre si vous ne définissez pas correctement les paramètres.
7. À propos de SVR (Support Vector Machine)
Le dernier est SVR (Support Vector Machine). Support Vector Machine (SVM) est un algorithme développé à l'origine pour résoudre les problèmes de classification binaire. Par conséquent, certaines personnes peuvent penser que seul le problème de classification peut être utilisé. En fait, SVM a un SVR qui étend la variable objectif à des valeurs continues afin qu'il puisse gérer les problèmes de régression. SVR a la particularité de pouvoir résoudre des problèmes de régression non linéaire avec une précision relativement élevée.
Le code python est ci-dessous.
#Importation de bibliothèque
from sklearn.svm import SVR
#Apprentissage de modèle
SVR = SVR(kernel='linear', C=1, epsilon=0.1, gamma='auto')
SVR.fit(x_train_std, y_train)
#Prévoir
pred_SVR = SVR.predict(x_test_std)
#Évaluation
#Coefficient de décision(R2)
r2_SVR = r2_score(y_test, pred_SVR)
#Erreur absolue moyenne(MAE)
mae_SVR = mean_absolute_error(y_test, pred_SVR)
print("R2 : %.3f" % r2_SVR)
print("MAE : %.3f" % mae_SVR)
#Coefficient de régression
print("Coef = ", SVR.coef_)
Cette fois, la fonction noyau utilisée (linéaire: régression linéaire). Puisqu'il existe quatre autres types de fonctions du noyau, le réglage des paramètres est nécessaire.
Le résultat de sortie est le suivant.
R2 : 0.780
MAE : 2.904
Coef = [[-1.18218512 0.62268229 0.09081358 0.4148341 -1.04510071 3.50961979
-0.40316769 -1.78305137 1.58605612 -1.78749695 -1.54742196 1.01255493
-2.35263548]]
Je voudrais afficher la valeur prédite et la valeur mesurée dans un diagramme de dispersion.
plt.xlabel("pred_SVR")
plt.ylabel("y_test")
plt.scatter(pred_SVR, y_test)
plt.show()
SVR n'est pas aussi précis que Random Forest et GBDT.
Résumé du script
Organisez le script jusqu'à présent.
#Bibliothèque pour le calcul des scores
import pandas as pd
import numpy as np
from sklearn.datasets import load_boston
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso
from sklearn.linear_model import ElasticNet
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.svm import SVR
def preprocess_sc(df):
"""Divisez les données en données d'entraînement et données d'évaluation et standardisez
Parameters
----------
df : pd.DataFrame
Ensemble de données (variable explicative + variable objective)
Returns
-------
x_train_std : pd.DataFrame
Données de formation après standardisation (variable explicative)
y_train : pd.DataFrame
Données d'entraînement (variable objective)
x_test_std : pd.DataFrame
Données d'évaluation après normalisation (variable explicative)
y_test : pd.DataFrame
Données d'évaluation (variable objective)
"""
x_train, x_test, y_train, y_test = train_test_split(df.iloc[:, 0:13], df.iloc[:, 13],
test_size=0.2, random_state=1)
#Standardiser les données
sc = StandardScaler()
sc.fit(x_train) #Standardisé avec les données d'entraînement
x_train_std = sc.transform(x_train)
x_test_std = sc.transform(x_test)
return x_train_std, x_test_std, y_train, y_test
def Linear_Regression(x_train_std, y_train, x_test_std):
"""Prédire par régression linéaire
Parameters
----------
x_train_std : pd.DataFrame
Données de formation après standardisation (variable explicative)
y_train : pd.DataFrame
Données d'entraînement (variable objective)
x_test_std : pd.DataFrame
Données d'évaluation après normalisation (variable explicative)
Returns
-------
pred_lr : pd.DataFrame
Résultat de la prédiction de la régression linéaire
"""
lr = LinearRegression()
lr.fit(x_train_std, y_train)
pred_lr = lr.predict(x_test_std)
return pred_lr
def Ridge_Regression(x_train_std, y_train, x_test_std, ALPHA=10.0):
"""Prédire avec régression Ridge
Parameters
----------
x_train_std : pd.DataFrame
Données de formation après standardisation (variable explicative)
y_train : pd.DataFrame
Données d'entraînement (variable objective)
x_test_std : pd.DataFrame
Données d'évaluation après normalisation (variable explicative)
ALPHA : float
Paramètre de régularisation α
Returns
-------
pred_ridge : pd.DataFrame
Résultats de la prédiction de la régression Ridge
"""
ridge = Ridge(alpha=ALPHA)
ridge.fit(x_train_std, y_train)
pred_ridge = ridge.predict(x_test_std)
return pred_ridge
def Lasso_Regression(x_train_std, y_train, x_test_std, ALPHA=0.05):
"""Prédire avec la régression Lasso
Parameters
----------
x_train_std : pd.DataFrame
Données de formation après standardisation (variable explicative)
y_train : pd.DataFrame
Données d'entraînement (variable objective)
x_test_std : pd.DataFrame
Données d'évaluation après normalisation (variable explicative)
ALPHA : float
Paramètre de régularisation α
Returns
-------
pred_lasso : pd.DataFrame
Résultat de la prédiction de la régression Lasso
"""
lasso = Lasso(alpha=ALPHA)
lasso.fit(x_train_std, y_train)
pred_lasso = lasso.predict(x_test_std)
return pred_lasso
def ElasticNet_Regression(x_train_std, y_train, x_test_std, ALPHA=0.05):
"""Prédire avec la régression ElasticNet
Parameters
----------
x_train_std : pd.DataFrame
Données de formation après standardisation (variable explicative)
y_train : pd.DataFrame
Données d'entraînement (variable objective)
x_test_std : pd.DataFrame
Données d'évaluation après normalisation (variable explicative)
ALPHA : float
Paramètre de régularisation α
Returns
-------
pred_elasticnet : pd.DataFrame
Résultats de la prédiction de la régression Elastic Net
"""
elasticnet = ElasticNet(alpha=ALPHA)
elasticnet.fit(x_train_std, y_train)
pred_elasticnet = elasticnet.predict(x_test_std)
return pred_elasticnet
def RandomForest_Regressor(x_train_std, y_train, x_test_std):
"""Prédire avec régression Random Forest
Parameters
----------
x_train_std : pd.DataFrame
Données de formation après standardisation (variable explicative)
y_train : pd.DataFrame
Données d'entraînement (variable objective)
x_test_std : pd.DataFrame
Données d'évaluation après normalisation (variable explicative)
Returns
-------
pred_RF : pd.DataFrame
Résultats de la prédiction de la régression RandomForest
"""
RF = RandomForestRegressor()
RF.fit(x_train_std, y_train)
pred_RF = RF.predict(x_test_std)
return pred_RF
def GradientBoosting_Regressor(x_train_std, y_train, x_test_std):
"""Prédire avec GBDT
Parameters
----------
x_train_std : pd.DataFrame
Données de formation après standardisation (variable explicative)
y_train : pd.DataFrame
Données d'entraînement (variable objective)
x_test_std : pd.DataFrame
Données d'évaluation après normalisation (variable explicative)
Returns
-------
pred_GBDT : pd.DataFrame
Résultats des prévisions GBDT
"""
GBDT = GradientBoostingRegressor()
GBDT.fit(x_train_std, y_train)
pred_GBDT = GBDT.predict(x_test_std)
return pred_GBDT
def SVR_Regression(x_train_std, y_train, x_test_std):
"""Prédire avec SVR
Parameters
----------
x_train_std : pd.DataFrame
Données de formation après standardisation (variable explicative)
y_train : pd.DataFrame
Données d'entraînement (variable objective)
x_test_std : pd.DataFrame
Données d'évaluation après normalisation (variable explicative)
Returns
-------
pred_SVR : pd.DataFrame
Résultats des prévisions GBDT
"""
svr = SVR()
svr.fit(x_train_std, y_train)
pred_SVR = svr.predict(x_test_std)
return pred_SVR
def main():
#Lire l'ensemble de données
boston = load_boston()
#Créer un bloc de données
#Stockage des variables explicatives
df = pd.DataFrame(boston.data, columns = boston.feature_names)
#Ajouter une variable objective
df['MEDV'] = boston.target
#Prétraitement des données
x_train_std, x_test_std, y_train, y_test = preprocess_sc(df)
pred_lr = pd.DataFrame(Linear_Regression(x_train_std, y_train, x_test_std))
pred_ridge = pd.DataFrame(Ridge_Regression(x_train_std, y_train, x_test_std, ALPHA=10.0))
pred_lasso = pd.DataFrame(Lasso_Regression(x_train_std, y_train, x_test_std, ALPHA=0.05))
pred_elasticnet = pd.DataFrame(ElasticNet_Regression(x_train_std, y_train, x_test_std, ALPHA=0.05))
pred_RF = pd.DataFrame(RandomForest_Regressor(x_train_std, y_train, x_test_std))
pred_GBDT = pd.DataFrame(GradientBoosting_Regressor(x_train_std, y_train, x_test_std))
pred_SVR = pd.DataFrame(SVR_Regression(x_train_std, y_train, x_test_std))
pred_all = pd.concat([df_lr, pred_ridge, pred_lasso, pred_elasticnet, pred_RF, pred_GBDT, pred_SVR], axis=1, sort=False)
pred_all.columns = ["df_lr", "pred_ridge", "pred_lasso", "pred_elasticnet", "pred_RF", "pred_GBDT", "pred_SVR"]
return pred_all
if __name__ == "__main__":
pred_all = main()
enfin
Merci d'avoir lu jusqu'au bout. Cependant, j'espère que vous comprenez qu'il existe différentes méthodes pour construire un modèle de prédiction. De plus, j'espère que vous avez trouvé que vous pouvez facilement implémenter n'importe lequel d'entre eux en utilisant scicit-learn.
En pratique, à partir de là, une évaluation plus approfondie de chaque modèle, un réglage des paramètres, une ingénierie de quantité de caractéristiques, etc. Il est nécessaire d'améliorer la précision.
Si vous avez une demande de correction, nous vous serions reconnaissants de bien vouloir nous contacter.