[PYTHON] Ich habe versucht, verschiedene Methoden für maschinelles Lernen (Vorhersagemodell) mithilfe von Scicit-Learn zu implementieren
- Artikel von Datenwissenschaftlern aus der Fertigungsindustrie
- Dieses Mal haben wir verschiedene Vorhersagemodelle mithilfe von Scikit-Learn implementiert und organisiert.
Einführung
Dieses Mal habe ich ein Vorhersagemodell für maschinelles Lernen mit scicit-learn implementiert. Ich habe auch die Punkte bei jeder Methode zusammengefasst.
Eine Reihe von Schritten zum Erstellen eines Vorhersagemodells
Der Ablauf beim Erstellen eines Vorhersagemodells ist nachstehend zusammengefasst. In jeder Phase gibt es wichtige Dinge, aber die Details werden separat organisiert.
(1) Anordnung der Probleme: Klären Sie die zu lösenden geschäftlichen Probleme (2) Datenerfassung: Organisieren Sie verfügbare Daten und bewerten Sie, ob das Ziel erreicht werden kann. (3) Grundtabelle der Daten: Visualisieren Sie die Eigenschaften der zu analysierenden Daten und analysieren Sie die Grundtabelle zusammen. (4) Datenvorverarbeitung: Bereinigen Sie die Daten, indem Sie den in den Daten verborgenen Staub entfernen (5) Extraktion der Merkmalsmenge: Entfernen Sie unnötige Merkmalsmengen und verwenden Sie nur die erforderlichen erklärenden Variablen (6) Datennormalisierung: Normalisieren Sie die Daten so, dass sie der Skala der Merkmalsmenge entsprechen (7) Auswahl der Methode: Wählen Sie eine geeignete Methode gemäß den Daten (8) Modelllernen: Lernen der Datenregeln nach der ausgewählten Methode (9) Modellüberprüfung / -bewertung: Bestätigen Sie die Vorhersagegenauigkeit der erlernten Methode und bewerten Sie die Gültigkeit des Modells.
Über Scikit-Learn
scikit-learn ist eine Python-Bibliothek für maschinelles Lernen.
Datensammlung
Dieses Mal werden wir ein Prognosemodell erstellen, das die im UCI Machine Learning Repository veröffentlichten Preisdaten von Boston Housing verwendet.
| Artikel | Überblick |
|---|---|
| Datensatz | ・ Bostoner Haus-price |
| Anzahl von Beispielen | 6 506 Stück |
| Anzahl der Spalten | ・ 14 Stück |
Der Python-Code ist unten.
#Importieren Sie die erforderlichen Bibliotheken
import pandas as pd
import numpy as np
from sklearn.datasets import load_boston
#Datensatz lesen
boston = load_boston()
#Erstellen eines Datenrahmens
#Speicherung erklärender Variablen
df = pd.DataFrame(boston.data, columns = boston.feature_names)
#Zielvariable hinzufügen
df['MEDV'] = boston.target
#Überprüfen Sie den Inhalt der Daten
df.head()
Die Erklärung jedes Spaltennamens wird weggelassen. ・ Erklärende Variablen: 13 ・ Zielvariable: 1 (MEDV)
Grundlegende Aggregation von Daten
Da es diesmal 13 erklärende Variablen gibt, werden wir ein multivariates Beziehungsdiagramm verwenden, um die Beziehungen zwischen jeder erklärenden Variablen und jeder objektiven Variablen effizient zu sehen. Dieses Mal möchte ich eine Bibliothek namens seaborn zur Visualisierung verwenden. Erstellen Sie zunächst ein multivariates Beziehungsdiagramm.
#Importieren Sie die erforderlichen Bibliotheken
import seaborn as sns
#Multivariates Korrelationsdiagramm
sns.pairplot(df, size=1.0)
Auf den ersten Blick scheinen RM (durchschnittliche Anzahl der Zimmer pro Wohneinheit) und MEDV (Hauspreis) eine positive Korrelation zu haben. Ich werde es etwas genauer analysieren, auch wenn ich es auf zwei einschränke.
#Beziehung zwischen RM (durchschnittliche Anzahl der Zimmer pro Wohneinheit) und MEDV (Hauspreis)
sns.regplot('RM','MEDV',data = df)
Betrachtet man die Beziehung im Detail so, so scheint es eine Korrelation zwischen RM (durchschnittliche Anzahl der Zimmer pro Wohneinheit) und MEDV (Hauspreis) zu geben.
Als nächstes möchte ich die Korrelationskoeffizientenmatrix finden.
#Berechnen Sie die Korrelationskoeffizientenmatrix
df.corr()
Datenvorverarbeitung
Bei der Vorverarbeitung muss in den Daten versteckter Staub (Ausreißer, Ausreißer, fehlende Werte) entfernt werden. Die Vorverarbeitung ist bei der Datenanalyse wichtig, diesmal werden wir jedoch nur auf fehlende Werte prüfen.
#Bestätigung fehlender Werte
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
Da in den Preisdaten von Bostoner Häusern keine Werte fehlen, werden wir sie so analysieren, wie sie sind.
Datennormalisierung
Dieses Mal ist das Feature-Quantity-Engineering ausgeschlossen (dies sollte tatsächlich durchgeführt werden). Als nächstes werden beim Erstellen des linearen Regressionsmodells die Daten in Trainingsdaten und Bewertungsdaten unterteilt. Danach wird eine Normalisierung durchgeführt, um der Skala der erklärenden Variablen zu entsprechen.
#Bibliotheksimport
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
#Erstellen Sie Trainingsdaten und Bewertungsdaten
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)
#Daten standardisieren
sc = StandardScaler()
sc.fit(x_train) #Standardisiert mit Trainingsdaten
x_train_std = sc.transform(x_train)
x_test_std = sc.transform(x_test)
Sobald dies erledigt ist, werden wir die Methode auswählen und das Vorhersagemodell erstellen. Dieses Mal habe ich beschlossen, die folgende Methode zu implementieren.
- Lineare Regression (multiple Regression)
- Ridge Regression
- Lasso-Regression
- Elastische Netzregression
- Zufällige Waldrückgabe
- GBDT (Gradient Boosting Tree)
- SVR (Support Vector Machine)
1. Über lineare Regression
Die allgemeine Vorhersageformel für die lineare Regression lautet wie folgt.
\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 $: Gewicht für erklärende Variable $ x_i $ (Rückgabekoeffizient) $ b $: Bias (Abschnitt)
#Bibliotheksimport
from sklearn.linear_model import LinearRegression
#Bibliothek zur Punkteberechnung
from sklearn.metrics import r2_score
from sklearn.metrics import mean_absolute_error
#Modelllernen
lr = LinearRegression()
lr.fit(x_train_std, y_train)
#Prognose
pred_lr = lr.predict(x_test_std)
#Auswertung
#Entscheidungskoeffizient(R2)
r2_lr = r2_score(y_test, pred_lr)
#Durchschnittlicher absoluter Fehler(MAE)
mae_lr = mean_absolute_error(y_test, pred_lr)
print("R2 : %.3f" % r2_lr)
print("MAE : %.3f" % mae_lr)
#Regressionskoeffizienten
print("Coef = ", lr.coef_)
#Sektion
print("Intercept =", lr.intercept_)
Das Ausgabeergebnis ist wie folgt.
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
Es ist nicht gut, nur nach dem numerischen Wert des Bewertungsindex zu urteilen, daher werde ich versuchen, den vorhergesagten Wert und den gemessenen Wert in einem Streudiagramm anzuzeigen.
#Bibliotheksimport
import matplotlib.pyplot as plt
%matplotlib inline
plt.xlabel("pred_lr")
plt.ylabel("y_test")
plt.scatter(pred_lr, y_test)
plt.show()
Angesichts dieses Ergebnisses glaube ich nicht, dass wir eine so seltsame Vorhersage getroffen haben. Eigentlich werden wir hier im Detail untersuchen, um die Genauigkeit zu verbessern, aber dieses Mal werden wir eine andere Methode ausprobieren.
2. Über Ridge Regression
Die Ridge-Regression ist die Verlustfunktion der linearen Regression mit einem Regularisierungsterm. Die Verlustfunktion der linearen Regression ist wie folgt.
\begin{eqnarray}
L = (\boldsymbol{y} - X\boldsymbol{w})^{T}(\boldsymbol{y}-X\boldsymbol{w})
\end{eqnarray}
$ \ boldsymbol {y} $: Vektorisierter Messwert der Zielvariablen $ \ boldsymbol {w} $: Vektorisierter Regressionskoeffizient $ X $: Eine Matrix von Messwerten aus $ n $ Anzahl der Proben und $ m $ Anzahl der erklärenden Variablen
Bei der Ridge-Regression ändert sich die Verlustfunktion wie folgt.
\begin{eqnarray}
L = (\boldsymbol{y} - X\boldsymbol{w})^{T}(\boldsymbol{y}-X\boldsymbol{w}) + λ||\boldsymbol{w}||_{2}^{2}
\end{eqnarray}
Bei der Ridge-Regression wird sie durch Hinzufügen des Quadrats der L2-Norm des Gewichts $ \ boldsymbol {w} $ wie oben beschrieben reguliert.
Der Python-Code ist unten. Mit Scikit-Learn ist das ganz einfach.
#Bibliotheksimport
from sklearn.linear_model import Ridge
#Modelllernen
ridge = Ridge(alpha=10)
ridge.fit(x_train_std, y_train)
#Prognose
pred_ridge = ridge.predict(x_test_std)
#Auswertung
#Entscheidungskoeffizient(R2)
r2_ridge = r2_score(y_test, pred_ridge)
#Durchschnittlicher absoluter Fehler(MAE)
mae_ridge = mean_absolute_error(y_test, pred_ridge)
print("R2 : %.3f" % r2_ridge)
print("MAE : %.3f" % mae_ridge)
#Regressionskoeffizienten
print("Coef = ", ridge.coef_)
Der Regularisierungsparameter ist entsprechend eingestellt (Standardwert für Scikit-Learn ist Alpha = 1,0). Das Ausgabeergebnis ist wie folgt.
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]
Ich möchte den vorhergesagten Wert und den gemessenen Wert in einem Streudiagramm anzeigen.
plt.xlabel("pred_ridge")
plt.ylabel("y_test")
plt.scatter(pred_ridge, y_test)
plt.show()
Es unterscheidet sich nicht wesentlich von der linearen Regression, da wir keine Parameter eingestellt oder ausgewählt haben.
3. Über die Lasso-Regression
Der Teil des Regularisierungsterms unterscheidet sich zwischen der Lasso-Regression und der Ridge-Regression. Bei der Lasso-Regression ändert sich die Verlustfunktion wie folgt.
\begin{eqnarray}
L = \frac{1}{2}(\boldsymbol{y} - X\boldsymbol{w})^{T}(\boldsymbol{y}-X\boldsymbol{w}) + λ||\boldsymbol{w}||_{1}
\end{eqnarray}
Die Lasso-Regression unterscheidet sich von der Ridge-Regression darin, dass der Regularisierungsterm die L1-Norm ist. Ich werde diesmal die Details weglassen.
Der Python-Code ist unten.
#Bibliotheksimport
from sklearn.linear_model import Lasso
#Modelllernen
lasso = Lasso(alpha=0.05)
lasso.fit(x_train_std, y_train)
#Prognose
pred_lasso = lasso.predict(x_test_std)
#Auswertung
#Entscheidungskoeffizient(R2)
r2_lasso = r2_score(y_test, pred_lasso)
#Durchschnittlicher absoluter Fehler(MAE)
mae_lasso = mean_absolute_error(y_test, pred_lasso)
print("R2 : %.3f" % r2_lasso)
print("MAE : %.3f" % mae_lasso)
#Regressionskoeffizienten
print("Coef = ", lasso.coef_)
Der Regularisierungsparameter ist entsprechend eingestellt (Standardwert für Scikit-Learn ist Alpha = 1,0). Das Ausgabeergebnis ist wie folgt.
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]
Ich möchte den vorhergesagten Wert und den gemessenen Wert in einem Streudiagramm anzeigen.
plt.xlabel("pred_lasso")
plt.ylabel("y_test")
plt.scatter(pred_lasso, y_test)
plt.show()
Die Lasso-Regression ändert sich auch nicht viel.
4. Informationen zur ElasticNet-Regression
Es ist eine Methode, die ElasticNet-Regression, L1-Regularisierung und L2-Regularisierung kombiniert.
Der Python-Code ist unten.
#Bibliotheksimport
from sklearn.linear_model import ElasticNet
#Modelllernen
elasticnet = ElasticNet(alpha=0.05)
elasticnet.fit(x_train_std, y_train)
#Prognose
pred_elasticnet = elasticnet.predict(x_test_std)
#Auswertung
#Entscheidungskoeffizient(R2)
r2_elasticnet = r2_score(y_test, pred_elasticnet)
#Durchschnittlicher absoluter Fehler(MAE)
mae_elasticnet = mean_absolute_error(y_test, pred_elasticnet)
print("R2 : %.3f" % r2_elasticnet)
print("MAE : %.3f" % mae_elasticnet)
#Regressionskoeffizienten
print("Coef = ", elasticnet.coef_)
Der Regularisierungsparameter ist entsprechend eingestellt (Standardwert für Scikit-Learn ist Alpha = 1,0). Das Ausgabeergebnis ist wie folgt.
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]
Ich möchte den vorhergesagten Wert und den gemessenen Wert in einem Streudiagramm anzeigen.
plt.xlabel("pred_elasticnet")
plt.ylabel("y_test")
plt.scatter(pred_elasticnet, y_test)
plt.show()
Die ElasticNet-Regression hat sich auch nicht wesentlich geändert.
5. Informationen zur zufälligen Waldregression
Als nächstes werden wir ein Vorhersagemodell für das Entscheidungsbaumsystem erstellen. Erstens ist die Random Forest-Regression.
RandomForest ist eine Sammlung vieler verschiedener Entscheidungsbäume, die auf dem Absacken des Ensemble-Lernens basieren. Der Nachteil des Entscheidungsbaums allein ist, dass es leicht zu überlernen ist, aber Random Forest ist eine Möglichkeit, dieses Problem zu lösen.
Der Python-Code ist unten.
#Bibliotheksimport
from sklearn.ensemble import RandomForestRegressor
#Modelllernen
RF = RandomForestRegressor()
RF.fit(x_train_std, y_train)
#Prognose
pred_RF = RF.predict(x_test_std)
#Auswertung
#Entscheidungskoeffizient(R2)
r2_RF = r2_score(y_test, pred_RF)
#Durchschnittlicher absoluter Fehler(MAE)
mae_RF = mean_absolute_error(y_test, pred_RF)
print("R2 : %.3f" % r2_RF)
print("MAE : %.3f" % mae_RF)
#Variable Bedeutung
print("feature_importances = ", RF.feature_importances_)
Die Parameter bleiben auf ihren Standardeinstellungen. Das Ausgabeergebnis ist wie folgt.
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]
Ich möchte den vorhergesagten Wert und den gemessenen Wert in einem Streudiagramm anzeigen.
plt.xlabel("pred_RF")
plt.ylabel("y_test")
plt.scatter(pred_RF, y_test)
plt.show()
Klingt besser als Regressionssystemmodelle (lineare Regression, Ridge-Regression, Lasso-Regression, ElasticNet-Regression). Ich denke, es ist nützlich zu wissen, dass RandomForest auch zurückkehren kann. Da RandomForest den Regressionskoeffizienten nicht kennt, bewerten wir die Gültigkeit des Modells anhand der Bedeutung von Variablen.
6. Über GBDT (Gradient Boosting Tree)
Als nächstes kommt GBDT (Gradient Boosting Tree).
GBDT gehört auch zum Lernen von Ensembles und ist ein Algorithmus, der darauf abzielt, die Generalisierungsleistung zu verbessern, indem nacheinander Entscheidungsbäume erstellt werden, die Fehler in bestimmten Entscheidungsbäumen korrigieren.
Der Python-Code ist unten.
#Bibliotheksimport
from sklearn.ensemble import GradientBoostingRegressor
#Modelllernen
GBDT = GradientBoostingRegressor()
GBDT.fit(x_train_std, y_train)
#Prognose
pred_GBDT = GBDT.predict(x_test_std)
#Auswertung
#Entscheidungskoeffizient(R2)
r2_GBDT = r2_score(y_test, pred_GBDT)
#Durchschnittlicher absoluter Fehler(MAE)
mae_GBDT = mean_absolute_error(y_test, pred_GBDT)
print("R2 : %.3f" % r2_GBDT)
print("MAE : %.3f" % mae_GBDT)
#Variable Bedeutung
print("feature_importances = ", GBDT.feature_importances_)
Die Parameter bleiben auf ihren Standardeinstellungen. Das Ausgabeergebnis ist wie folgt.
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]
Ich möchte den vorhergesagten Wert und den gemessenen Wert in einem Streudiagramm anzeigen.
plt.xlabel("pred_GBDT")
plt.ylabel("y_test")
plt.scatter(pred_GBDT, y_test)
plt.show()
Es ist die bisher genaueste Methode. Beachten Sie jedoch, dass GBDT leicht zu überlernen ist, wenn Sie die Parameter nicht richtig einstellen.
7. Über SVR (Support Vector Machine)
Der letzte ist SVR (Support Vector Machine). Support Vector Machine (SVM) ist ein Algorithmus, der ursprünglich zur Lösung von Problemen bei der binären Klassifizierung entwickelt wurde. Daher denken einige Leute möglicherweise, dass nur das Klassifizierungsproblem verwendet werden kann. Tatsächlich verfügt SVM über einen SVR, der die Zielvariable auf kontinuierliche Werte erweitert, damit Regressionsprobleme behandelt werden können. SVR hat die Eigenschaft, nichtlineare Regressionsprobleme mit relativ hoher Genauigkeit lösen zu können.
Der Python-Code ist unten.
#Bibliotheksimport
from sklearn.svm import SVR
#Modelllernen
SVR = SVR(kernel='linear', C=1, epsilon=0.1, gamma='auto')
SVR.fit(x_train_std, y_train)
#Prognose
pred_SVR = SVR.predict(x_test_std)
#Auswertung
#Entscheidungskoeffizient(R2)
r2_SVR = r2_score(y_test, pred_SVR)
#Durchschnittlicher absoluter Fehler(MAE)
mae_SVR = mean_absolute_error(y_test, pred_SVR)
print("R2 : %.3f" % r2_SVR)
print("MAE : %.3f" % mae_SVR)
#Regressionskoeffizienten
print("Coef = ", SVR.coef_)
Diesmal wird die Kernelfunktion verwendet (linear: lineare Regression). Da es vier weitere Arten von Kernelfunktionen gibt, ist eine Parameteroptimierung erforderlich.
Das Ausgabeergebnis ist wie folgt.
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]]
Ich möchte den vorhergesagten Wert und den gemessenen Wert in einem Streudiagramm anzeigen.
plt.xlabel("pred_SVR")
plt.ylabel("y_test")
plt.scatter(pred_SVR, y_test)
plt.show()
SVR ist im Vergleich zu Random Forest und GBDT nicht so genau.
Zusammenfassung des Skripts
Organisieren Sie das Skript bisher.
#Bibliothek zur Punkteberechnung
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):
"""Teilen Sie die Daten in Trainingsdaten und Bewertungsdaten auf und standardisieren Sie sie
Parameters
----------
df : pd.DataFrame
Datensatz (erklärende Variable + Zielvariable)
Returns
-------
x_train_std : pd.DataFrame
Trainingsdaten nach Standardisierung (erklärende Variable)
y_train : pd.DataFrame
Trainingsdaten (Zielvariable)
x_test_std : pd.DataFrame
Bewertungsdaten nach Standardisierung (erklärende Variable)
y_test : pd.DataFrame
Bewertungsdaten (Zielvariable)
"""
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)
#Daten standardisieren
sc = StandardScaler()
sc.fit(x_train) #Standardisiert mit Trainingsdaten
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):
"""Vorhersage durch lineare Regression
Parameters
----------
x_train_std : pd.DataFrame
Trainingsdaten nach Standardisierung (erklärende Variable)
y_train : pd.DataFrame
Trainingsdaten (Zielvariable)
x_test_std : pd.DataFrame
Bewertungsdaten nach Standardisierung (erklärende Variable)
Returns
-------
pred_lr : pd.DataFrame
Vorhersageergebnis der linearen Regression
"""
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):
"""Vorhersage mit Ridge-Regression
Parameters
----------
x_train_std : pd.DataFrame
Trainingsdaten nach Standardisierung (erklärende Variable)
y_train : pd.DataFrame
Trainingsdaten (Zielvariable)
x_test_std : pd.DataFrame
Bewertungsdaten nach Standardisierung (erklärende Variable)
ALPHA : float
Regularisierungsparameter α
Returns
-------
pred_ridge : pd.DataFrame
Ergebnisse der Ridge-Regressionsvorhersage
"""
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):
"""Vorhersage mit Lasso-Regression
Parameters
----------
x_train_std : pd.DataFrame
Trainingsdaten nach Standardisierung (erklärende Variable)
y_train : pd.DataFrame
Trainingsdaten (Zielvariable)
x_test_std : pd.DataFrame
Bewertungsdaten nach Standardisierung (erklärende Variable)
ALPHA : float
Regularisierungsparameter α
Returns
-------
pred_lasso : pd.DataFrame
Vorhersageergebnis der Lasso-Regression
"""
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):
"""Vorhersage mit ElasticNet-Regression
Parameters
----------
x_train_std : pd.DataFrame
Trainingsdaten nach Standardisierung (erklärende Variable)
y_train : pd.DataFrame
Trainingsdaten (Zielvariable)
x_test_std : pd.DataFrame
Bewertungsdaten nach Standardisierung (erklärende Variable)
ALPHA : float
Regularisierungsparameter α
Returns
-------
pred_elasticnet : pd.DataFrame
Ergebnisse der Vorhersage der elastischen Netzregression
"""
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):
"""Vorhersage mit zufälliger Waldregression
Parameters
----------
x_train_std : pd.DataFrame
Trainingsdaten nach Standardisierung (erklärende Variable)
y_train : pd.DataFrame
Trainingsdaten (Zielvariable)
x_test_std : pd.DataFrame
Bewertungsdaten nach Standardisierung (erklärende Variable)
Returns
-------
pred_RF : pd.DataFrame
Ergebnisse der RandomForest-Regressionsvorhersage
"""
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):
"""Mit GBDT vorhersagen
Parameters
----------
x_train_std : pd.DataFrame
Trainingsdaten nach Standardisierung (erklärende Variable)
y_train : pd.DataFrame
Trainingsdaten (Zielvariable)
x_test_std : pd.DataFrame
Bewertungsdaten nach Standardisierung (erklärende Variable)
Returns
-------
pred_GBDT : pd.DataFrame
GBDT-Prognoseergebnisse
"""
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):
"""Mit SVR vorhersagen
Parameters
----------
x_train_std : pd.DataFrame
Trainingsdaten nach Standardisierung (erklärende Variable)
y_train : pd.DataFrame
Trainingsdaten (Zielvariable)
x_test_std : pd.DataFrame
Bewertungsdaten nach Standardisierung (erklärende Variable)
Returns
-------
pred_SVR : pd.DataFrame
GBDT-Prognoseergebnisse
"""
svr = SVR()
svr.fit(x_train_std, y_train)
pred_SVR = svr.predict(x_test_std)
return pred_SVR
def main():
#Datensatz lesen
boston = load_boston()
#Erstellen eines Datenrahmens
#Speicherung erklärender Variablen
df = pd.DataFrame(boston.data, columns = boston.feature_names)
#Zielvariable hinzufügen
df['MEDV'] = boston.target
#Datenvorverarbeitung
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()
schließlich
Vielen Dank für das Lesen bis zum Ende. Ich hoffe jedoch, dass Sie verstehen, dass es verschiedene Methoden zum Erstellen eines Vorhersagemodells gibt. Ich hoffe auch, dass Sie festgestellt haben, dass Sie diese mithilfe von scicit-learn problemlos implementieren können.
In der Praxis werden von hier aus weitere Bewertungen jedes Modells, Parameterabstimmungen, Merkmalsmengen-Engineering usw. durchgeführt. Es ist notwendig, die Genauigkeit zu verbessern.
Wenn Sie eine Korrekturanfrage haben, würden wir uns freuen, wenn Sie uns kontaktieren könnten.
Recommended Posts