Einführung

Wir werden 28 Arten von sklearn-Regressionsmodellen ausprobieren und ein Diagramm der Genauigkeit erstellen.

Als Werkzeug zum Ausprobieren vieler Modelle für maschinelles Lernen gibt es viele wunderbare und praktische Werkzeuge wie das AutoML-System und kürzlich PyCaret, aber ich möchte selbst ein Modell vorbereiten. Da es etwas gab, werde ich ein Memorandum hinterlassen.

Umgebung

Python 3.6.10
scikit-learn 0.22.0

Code

Regressionsmodell importieren

Importieren Sie die erforderlichen Modelle und kombinieren Sie alle Regressionsmodellinstanzen.

from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet, SGDRegressor
from sklearn.linear_model import PassiveAggressiveRegressor, ARDRegression, RidgeCV
from sklearn.linear_model import TheilSenRegressor, RANSACRegressor, HuberRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.svm import SVR, LinearSVR
from sklearn.neighbors import KNeighborsRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.experimental import enable_hist_gradient_boosting
from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor, ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.ensemble import BaggingRegressor, GradientBoostingRegressor, VotingRegressor, StackingRegressor
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.cross_decomposition import PLSRegression

reg_dict = {"LinearRegression": LinearRegression(),
            "Ridge": Ridge(),
            "Lasso": Lasso(),
            "ElasticNet": ElasticNet(), 
            "Polynomial_deg2": Pipeline([('poly', PolynomialFeatures(degree=2)),('linear', LinearRegression())]),
            "Polynomial_deg3": Pipeline([('poly', PolynomialFeatures(degree=3)),('linear', LinearRegression())]),
            "Polynomial_deg4": Pipeline([('poly', PolynomialFeatures(degree=4)),('linear', LinearRegression())]),
            "Polynomial_deg5": Pipeline([('poly', PolynomialFeatures(degree=5)),('linear', LinearRegression())]),
            "KNeighborsRegressor": KNeighborsRegressor(n_neighbors=3),
            "DecisionTreeRegressor": DecisionTreeRegressor(),
            "RandomForestRegressor": RandomForestRegressor(),
            "SVR": SVR(kernel='rbf', C=1e3, gamma=0.1, epsilon=0.1),
            "GaussianProcessRegressor": GaussianProcessRegressor(),
            "SGDRegressor": SGDRegressor(),
            "MLPRegressor": MLPRegressor(hidden_layer_sizes=(10,10), max_iter=100, early_stopping=True, n_iter_no_change=5),
            "ExtraTreesRegressor": ExtraTreesRegressor(n_estimators=100), 
            "PLSRegression": PLSRegression(n_components=10),
            "PassiveAggressiveRegressor": PassiveAggressiveRegressor(max_iter=100, tol=1e-3),
            "TheilSenRegressor": TheilSenRegressor(random_state=0),
            "RANSACRegressor": RANSACRegressor(random_state=0),
            "HistGradientBoostingRegressor": HistGradientBoostingRegressor(),
            "AdaBoostRegressor": AdaBoostRegressor(random_state=0, n_estimators=100),
            "BaggingRegressor": BaggingRegressor(base_estimator=SVR(), n_estimators=10),
            "GradientBoostingRegressor": GradientBoostingRegressor(random_state=0),
            "VotingRegressor": VotingRegressor([('lr', LinearRegression()), ('rf', RandomForestRegressor(n_estimators=10))]),
            "StackingRegressor": StackingRegressor(estimators=[('lr', RidgeCV()), ('svr', LinearSVR())], final_estimator=RandomForestRegressor(n_estimators=10)),
            "ARDRegression": ARDRegression(),
            "HuberRegressor": HuberRegressor(),
                    }

** Achtung 1 ** Die Argumente jedes Regressionsmodells sind recht strukturiert, und der obige Code ist nur ein Beispiel. Bei der Verwendung wird dringend empfohlen, den Datenwert entsprechend festzulegen oder ihn mit einer Hyperparameteroptimierung wie der Rastersuche zu kombinieren.

** Achtung 2 ** Polynom_deg2 ~ 5 ist eine Regression durch eine Funktion 2 ~ 5. Ordnung. In der sklearn-Formel finden Sie eine Beschreibung anderer Modelle.

Generierung und Training von Regressionsdaten

Verwenden Sie "make_regression" von sklearn, um Daten für die Regression zu generieren.

Darüber hinaus werden alle Modelle jeweils zehnmal trainiert und abgeleitet und nach Genauigkeit sortiert (hier wird MAPE verwendet).

from sklearn.model_selection import train_test_split
import random
from sklearn.datasets import make_regression
import numpy as np

def mean_absolute_percentage_error(y_true, y_pred):
    """MAPE"""
    return np.mean(np.abs((y_true - y_pred) / y_true)) * 100

test_size = 0.3  #Teilungsverhältnis
N_trials = 10  #Anzahl von Versuchen

#Generieren Sie zu regressierende Daten
x, y = make_regression(random_state=12, 
                       n_samples=100, 
                       n_features=10,
                       n_informative=4,
                       noise=10.0,
                       bias=0.0)

mape_dict = {reg_name:[] for reg_name in reg_dict.keys()}  #Präzisionsgewölbe

for i in range(N_trials):
    print(f"Trial {i+1}")
    random_state = random.randint(0, 1000)
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=test_size, random_state=random_state)

    for reg_name, reg in reg_dict.items():
        reg.fit(x_train,y_train)
        y_pred = reg.predict(x_test)
        mape = mean_absolute_percentage_error(y_test, y_pred)  #MAPE berechnen
        mape_dict[reg_name].append(mape)  #Speicherung

#Sortieren nach dem Durchschnittswert von MAPE
mape_dict_sorted = {key: value for key, value in reversed(sorted(mape_dict.items(), key=lambda x:np.mean(x[1])))}

Ergebnisplot

Oben wurde MAPE für alle Modelle zehnmal gemessen und nach dem Durchschnittswert von MAPE sortiert.

Bei der Beurteilung der Qualität eines maschinellen Lernmodells möchten wir neben dem Durchschnittswert der Genauigkeit auch den Grad der Dispersion (Index wie Dispersion) berücksichtigen.

Zeichnen Sie daher ein Box-Whisker-Diagramm.

Je kleiner die MAPE ist, desto besser. In der Abbildung ist das obere Modell also besser und je kleiner die Box-Whisker sind, desto stabiler ist das Modell.

import matplotlib.pyplot as plt
import matplotlib.cm as cm
from matplotlib.colors import Normalize

plt.rcParams["font.size"] = 18  #Erhöhen Sie die Schriftgröße
scalarMap = cm.ScalarMappable(norm=Normalize(vmin=0, vmax=len(mape_dict)), cmap=plt.get_cmap('gist_rainbow_r'))

plt.figure(figsize=(15,9))
box=plt.boxplot(mape_dict_sorted.values(), vert=False, patch_artist=True,labels=mape_dict_sorted.keys())
for i, patch in enumerate(box['boxes']):
    patch.set_facecolor(scalarMap.to_rgba(i))
plt.title("MAPE Box Plot")
plt.xlabel("MAPE")
plt.ylabel("Regressor Name")
plt.show()