[PYTHON] J'ai essayé d'implémenter diverses méthodes d'apprentissage automatique (modèle de prédiction) en utilisant scicit-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()

スクリーンショット 2020-11-09 20.33.13.png

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)

スクリーンショット 2020-11-09 20.52.30.png

À 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)

スクリーンショット 2020-11-09 21.12.36.png

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()

スクリーンショット 2020-11-09 21.26.30.png

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.

  1. Régression linéaire (régression multiple)
  2. Régression Ridge
  3. Régression par lasso
  4. Régression Elastic Net
  5. Retour aléatoire dans la forêt
  6. GBDT (arbre d'amplification de gradient)
  7. 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()

スクリーンショット 2020-11-10 20.52.36.png

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()

スクリーンショット 2020-11-10 21.18.04.png

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()

スクリーンショット 2020-11-10 21.37.19.png

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()

スクリーンショット 2020-11-10 22.04.43.png

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()

スクリーンショット 2020-11-10 22.22.32.png

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()

スクリーンショット 2020-11-10 22.29.32.png

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()

スクリーンショット 2020-11-10 23.19.19.png

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.

Recommended Posts

J'ai essayé d'implémenter diverses méthodes d'apprentissage automatique (modèle de prédiction) en utilisant scicit-learn
J'ai essayé de compresser l'image en utilisant l'apprentissage automatique
J'ai essayé d'utiliser Tensorboard, un outil de visualisation pour l'apprentissage automatique
J'ai essayé d'appeler l'API de prédiction du modèle d'apprentissage automatique de WordPress
J'ai essayé de classer les accords de guitare en temps réel en utilisant l'apprentissage automatique
J'ai essayé de visualiser le modèle avec la bibliothèque d'apprentissage automatique low-code "PyCaret"
J'ai essayé d'implémenter TOPIC MODEL en Python
J'ai essayé d'organiser les index d'évaluation utilisés en machine learning (modèle de régression)
[Python] Deep Learning: J'ai essayé d'implémenter Deep Learning (DBN, SDA) sans utiliser de bibliothèque.
Un débutant en apprentissage automatique a essayé de créer un modèle de prédiction de courses de chevaux avec python
J'ai essayé de prédire l'évolution de la quantité de neige pendant 2 ans par apprentissage automatique
J'ai essayé de traiter et de transformer l'image et d'élargir les données pour l'apprentissage automatique
J'ai essayé de déplacer l'apprentissage automatique (détection d'objet) avec TouchDesigner
J'ai essayé d'implémenter PCANet
J'ai essayé d'implémenter StarGAN (1)
J'ai essayé de créer un environnement d'apprentissage automatique avec Python (Mac OS X)
J'ai essayé de mettre en œuvre le modèle de base du réseau neuronal récurrent
J'ai essayé différentes méthodes pour envoyer du courrier japonais avec Python
J'ai essayé d'implémenter la détection d'anomalies par apprentissage de structure clairsemée
J'ai essayé d'héberger un modèle d'apprentissage en profondeur de TensorFlow à l'aide de TensorFlow Serving
[TF] J'ai essayé de visualiser le résultat de l'apprentissage en utilisant Tensorboard
[Apprentissage automatique] J'ai essayé de résumer la théorie d'Adaboost
J'ai essayé d'implémenter Perceptron Part 1 [Deep Learning from scratch]
J'ai essayé d'écrire dans un modèle de langage profondément appris
J'ai essayé d'implémenter SSD avec PyTorch maintenant (édition du modèle)
J'ai essayé de comparer la précision des modèles d'apprentissage automatique en utilisant kaggle comme thème.
Application correspondante, j'ai essayé de prendre des statistiques de personnes fortes et j'ai essayé de créer un modèle d'apprentissage automatique
J'ai essayé d'implémenter Deep VQE
J'ai essayé l'apprentissage automatique avec liblinear
J'ai essayé de mettre en place une validation contradictoire
J'ai essayé l'apprentissage par renforcement avec PyBrain
J'ai essayé l'apprentissage en profondeur avec Theano
J'ai essayé d'implémenter Realness GAN
J'ai essayé d'utiliser GLM (modèle linéaire généralisé) pour les données de prix des actions
J'ai essayé de résoudre le problème de planification des équipes par diverses méthodes
Mémo d'apprentissage Python pour l'apprentissage automatique par Chainer Chapitre 9 Introduction à scikit-learn
[Apprentissage automatique] J'ai essayé de faire quelque chose comme passer des images
[Python] J'ai essayé d'obtenir diverses informations en utilisant l'API de données YouTube!
J'ai essayé de comprendre l'apprentissage supervisé de l'apprentissage automatique d'une manière facile à comprendre, même pour les ingénieurs serveurs 1
J'ai essayé de comprendre l'apprentissage supervisé de l'apprentissage automatique d'une manière facile à comprendre, même pour les ingénieurs serveurs 2
J'ai essayé d'implémenter PLSA en Python
J'ai essayé d'utiliser Azure Speech to Text.
scikit-learn Comment utiliser le résumé (apprentissage automatique)
J'ai essayé de mettre en œuvre un apprentissage en profondeur qui n'est pas profond avec uniquement NumPy
J'ai essayé d'implémenter Autoencoder avec TensorFlow
J'ai essayé d'implémenter la permutation en Python
[Apprentissage automatique] Classification des sujets LDA à l'aide de scikit-learn
J'ai installé Python 3.5.1 pour étudier l'apprentissage automatique
Une introduction à OpenCV pour l'apprentissage automatique
J'ai essayé d'implémenter PLSA dans Python 2
[Deep Learning from scratch] J'ai essayé d'implémenter la couche sigmoïde et la couche Relu
[Kaggle] J'ai essayé l'apprentissage d'ensemble avec LightGBM
J'ai appris le grattage à l'aide de sélénium pour créer un modèle de prédiction de courses de chevaux.
[ML-Aents] J'ai essayé l'apprentissage automatique en utilisant TensorFlow de Unity et Python (compatible v0.11β)
J'ai essayé de comprendre attentivement la fonction d'apprentissage dans le réseau de neurones sans utiliser la bibliothèque d'apprentissage automatique (deuxième moitié)
J'ai essayé de classer le texte en utilisant TensorFlow
[Renforcer l'apprentissage] Enfin surpassé les humains! ?? J'ai essayé d'expliquer / d'implémenter Agent57 (Keras-RL)