[PYTHON] Überwachtes maschinelles Lernen (Klassifikation / Regression)

"Gelehrtes maschinelles Lernen", um die Funktion $ f $ so zu finden, dass $ y = f (X) $ ist, wenn die entsprechende Zielvariable $ y $ für eine erklärende Variable $ X_n $ bekannt ist Wird genannt. Die einfachsten davon sind "lineare einfache Regression" und "lineare multiple Regression".

• Regression ... Wenn die Zielvariable $ y $ ein kontinuierlicher Wert ist
• Klassifizierung ... Wenn die Zielvariable $ y $ ein diskreter Wert ist

Klassifizierungsproblem

Als Beispiel werden wir die Daten "Pima Indian Diabetes Diagnosis" verwenden.

#Importieren Sie eine Bibliothek, die den Zugriff auf Ressourcen per URL ermöglicht.
import urllib.request 
#Geben Sie Ressourcen im Web an
url = 'https://raw.githubusercontent.com/maskot1977/ipython_notebook/master/toydata/pima-indians-diabetes.txt'
#Laden Sie die Ressource von der angegebenen URL herunter und geben Sie ihr einen Namen.
urllib.request.urlretrieve(url, 'pima-indians-diabetes.txt') 

('pima-indians-diabetes.txt', <http.client.HTTPMessage at 0x7fd16c201550>)

#Importieren einer Bibliothek zum Verarbeiten von Daten, die wie eine Tabellenberechnung aussehen
import pandas as pd 
#Daten lesen und als Datenrahmenformat speichern
df = pd.read_csv('pima-indians-diabetes.txt', delimiter="\t", index_col=0)
#Überprüfen Sie den Inhalt
df

768 rows × 9 columns

Die obige "Klasse" ist die Zielvariable $ y $, und wenn sie 1 ist, wird beurteilt, dass sie nicht diabetisch ist, und wenn sie 0 ist, wird beurteilt, dass sie nicht diabetisch ist. Lassen Sie uns ein Modell erstellen, das es vorhersagt.

#Erklärende Variable
X = df.iloc[:, :8]
#Normalisierung so, dass der Maximalwert 1 und der Minimalwert 0 ist.
# axis=Wenn 1, wird es nach Zeile anstelle von Spalte normalisiert.
X = X.apply(lambda x: (x-x.min())/(x.max() - x.min()), axis=0)

#Objektive Variable
y = df.iloc[:, 8]

Teilen Sie in Trainingsdaten und Testdaten

Beim maschinellen Lernen werden bekannte Daten in Trainingsdaten (auch als Lehrerdaten und Lehrersatz bezeichnet) und Testdaten (auch als Testsatz bezeichnet) unterteilt, um ihre Leistung zu bewerten. Ein Vorhersagemodell wird durch Training (Lernen) unter Verwendung der Trainingsdaten erstellt, und die Leistungsbewertung wird basierend darauf durchgeführt, wie genau die Testdaten vorhergesagt werden können, die bei der Erstellung des Vorhersagemodells nicht verwendet wurden. Eine solche Bewertungsmethode wird als "Kreuzvalidierung" bezeichnet. Hier,

• Trainingsdaten (60% aller Daten)

• X_train: Erklärende Variablen für Trainingsdaten

• y_train: Objektive Variable der Trainingsdaten

• Testdaten (40% aller Daten)

• X_test: Erklärende Variable für Testdaten

• y_test: Objektive Variable der Testdaten

Dann wollen wir die Beziehung zwischen X_train und y_train lernen und y_test aus X_test vorhersagen.

Die maschinelle Lernbibliothek von Python, scikit-learn, bietet Methoden zur Aufteilung in Trainings- und Testdaten.

• https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html

#Importmethode zur Aufteilung in Trainingsdaten und Testdaten
from sklearn.model_selection import train_test_split 
#Zu Trainingsdaten / Testdaten 6:Zufällig geteilt durch ein Verhältnis von 4
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4) 

Logistische Rückgabe

Die logistische Regression ähnelt der linearen multiplen Regression, jedoch mit einem diskreten Wert, ob die Zielvariable $ y $ 0 oder 1 ist. In meiner letzten Vorlesung habe ich die logistische Regression mithilfe der Scipy-Bibliothek implementiert. In der Praxis ist es jedoch bequemer, Scikit-Learn zu verwenden.

Überprüfen Sie, welche Methoden und Parameter auf den folgenden Websites verfügbar sind.

• https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html

from sklearn.linear_model import LogisticRegression #Logistische Rückgabe
classifier = LogisticRegression() #Klassifikator generieren
classifier.fit(X_train, y_train) #Lernen

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
                   intercept_scaling=1, l1_ratio=None, max_iter=100,
                   multi_class='warn', n_jobs=None, penalty='l2',
                   random_state=None, solver='warn', tol=0.0001, verbose=0,
                   warm_start=False)

Zeitmessung

Es ist nützlich, timeit zu verwenden, um die zum Lernen erforderliche Zeit zu messen.

import timeit #Bibliothek zur Messung der Ausführungszeit
timeit.timeit(lambda: classifier.fit(X_train, y_train), number=1)

0.006864218999993454

Berechnung der richtigen Antwortrate

Es muss zwischen "Klassifizierungsgenauigkeit der für das Training verwendeten Daten" und "Klassifizierungsgenauigkeit der nicht für das Training verwendeten Daten" unterschieden werden. Modelle mit einem extrem hohen und einem niedrigen letzteren haben eine geringe Generalisierungsleistung und werden als "überpasst" bezeichnet.

#Richtige Antwortrate(train) :Wie genau können die für das Training verwendeten Daten vorhergesagt werden?
classifier.score(X_train,y_train)

0.7800289435600579

#Richtige Antwortrate(test) :Wie genau können Sie die Daten vorhersagen, die nicht für das Training verwendet wurden?
classifier.score(X_test,y_test)

0.7402597402597403

Vorhersage von Daten, die nicht für die Trainings- und Verwirrungsmatrix verwendet werden

Es ist möglich, nicht nur die Genauigkeitsrate vorherzusagen, sondern auch, welche Daten speziell in welche klassifiziert sind.

#Vorhersagen von Daten, die nicht für das Training verwendet werden
y_pred = classifier.predict(X_test)

y_pred

array([1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
       0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0])

Wenn Sie die richtige Antwort kennen, können Sie die Antworten abgleichen. Die Verwirrungsmatrix ist für diese Aggregation nützlich.

from sklearn.metrics import confusion_matrix #Methode zur Berechnung der Verwirrungsmatrix
#Eine Verwirrungsmatrix, die zeigt, wie gut das Vorhersageergebnis und die richtige Antwort (wahre Antwort) übereinstimmen.
pd.DataFrame(confusion_matrix(y_pred, y_test), 
             index=['predicted 0', 'predicted 1'], columns=['real 0', 'real 1'])

ROC-Kurve / PR-Kurve

Welche Daten in welche klassifiziert werden, wird anhand der "Vertrauensstärke" in jeder Klassifizierung beurteilt. Indem Sie sie in der Reihenfolge des starken Vertrauens anordnen, können Sie ROC-Kurven und PR-Kurven zeichnen und die Leistung des Vorhersagemodells bewerten.

#Berechnen Sie die Vertrauensstärke in die Vorhersageergebnisse
y_proba = classifier.predict_proba(X_test)

y_proba

array([[0.21417054, 0.78582946],
       [0.46404957, 0.53595043],
       [0.70401466, 0.29598534],
       [0.75314361, 0.24685639],
       [0.76452966, 0.23547034],
       [0.33685542, 0.66314458],
       [0.76393323, 0.23606677],
       [0.82487552, 0.17512448],
       [0.87720401, 0.12279599],
       [0.83530283, 0.16469717],
       [0.64980016, 0.35019984],
       [0.78574888, 0.21425112],
       [0.51054138, 0.48945862],
       [0.24870259, 0.75129741],
       [0.91082684, 0.08917316],
       [0.86200773, 0.13799227],
       [0.71562431, 0.28437569],
       [0.62886446, 0.37113554],
       [0.63181921, 0.36818079],
       [0.77975231, 0.22024769],
       [0.65396517, 0.34603483],
       [0.81535938, 0.18464062],
       [0.54607196, 0.45392804],
       [0.79688063, 0.20311937],
       [0.80333846, 0.19666154],
       [0.728435  , 0.271565  ],
       [0.36817034, 0.63182966],
       [0.54025915, 0.45974085],
       [0.6614052 , 0.3385948 ],
       [0.74309548, 0.25690452],
       [0.92572332, 0.07427668],
       [0.80406998, 0.19593002],
       [0.61165474, 0.38834526],
       [0.43564389, 0.56435611],
       [0.42922327, 0.57077673],
       [0.61369072, 0.38630928],
       [0.68195508, 0.31804492],
       [0.86971152, 0.13028848],
       [0.81006182, 0.18993818],
       [0.86324924, 0.13675076],
       [0.82269894, 0.17730106],
       [0.48717372, 0.51282628],
       [0.72772261, 0.27227739],
       [0.81581007, 0.18418993],
       [0.54651378, 0.45348622],
       [0.65486361, 0.34513639],
       [0.69695761, 0.30304239],
       [0.50397912, 0.49602088],
       [0.70579261, 0.29420739],
       [0.56812519, 0.43187481],
       [0.28702944, 0.71297056],
       [0.78684682, 0.21315318],
       [0.77913962, 0.22086038],
       [0.20665217, 0.79334783],
       [0.64020202, 0.35979798],
       [0.54394942, 0.45605058],
       [0.74972094, 0.25027906],
       [0.89307226, 0.10692774],
       [0.63129007, 0.36870993],
       [0.775181  , 0.224819  ],
       [0.88651222, 0.11348778],
       [0.83087546, 0.16912454],
       [0.52015754, 0.47984246],
       [0.17895175, 0.82104825],
       [0.68620306, 0.31379694],
       [0.6503939 , 0.3496061 ],
       [0.53702941, 0.46297059],
       [0.74395419, 0.25604581],
       [0.79430285, 0.20569715],
       [0.70717315, 0.29282685],
       [0.74036824, 0.25963176],
       [0.35031104, 0.64968896],
       [0.59128595, 0.40871405],
       [0.62945511, 0.37054489],
       [0.85812094, 0.14187906],
       [0.95492842, 0.04507158],
       [0.82726693, 0.17273307]])

#Importieren Sie eine Bibliothek, um Diagramme und Grafiken zu veranschaulichen.
import matplotlib.pyplot as plt
%matplotlib inline

Hier ist die Methode zur Behandlung der ROC-Kurve und des darunter liegenden AUC-Werts.

• https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html

• https://scikit-learn.org/stable/modules/generated/sklearn.metrics.auc.html

from sklearn.metrics import roc_curve
from sklearn.metrics import auc

#Geben Sie eine AUC-Punktzahl
fpr, tpr, thresholds = roc_curve(y_test, y_proba[:, 1])
roc_auc = auc(fpr, tpr)
print ("AUC curve : %f" % roc_auc)

#Zeichnen Sie eine ROC-Kurve
plt.figure(figsize=(4,4))
plt.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], 'k--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.0])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC curve: AUC=%0.2f' % roc_auc)
plt.legend(loc="lower right")
plt.show()

AUC curve : 0.756560

In ähnlicher Weise ist hier die Methode zum Zeichnen einer PR-Kurve.

• https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html

from sklearn.metrics import auc
from sklearn.metrics import precision_recall_curve
precision, recall, thresholds = precision_recall_curve(y_test, y_proba[:, 1])
area = auc(recall, precision)
print ("AUPR score: %0.2f" % area)

#Zeichnen Sie eine PR-Kurve
plt.figure(figsize=(4,4))
plt.plot(recall, precision, label='Precision-Recall curve')
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.ylim([0.0, 1.05])
plt.xlim([0.0, 1.0])
plt.title('Precision-Recall curve: AUPR=%0.2f' % area)
plt.legend(loc="lower left")
plt.show()

AUPR score: 0.68

Parametereinstellung durch Rastersuche

Methoden für maschinelles Lernen erfordern viele Parameter. Der Standard (Standard) ist keine gute Vorhersage. Eine Möglichkeit, gute Parameter zu finden, ist die "Rastersuche". GridSearchCV unterteilt die Trainingsdaten weiter (standardmäßig dreiteilige Kreuzvalidierung), probiert alle Kombinationen von Parameterkandidaten aus und sucht nach Parametern, die im Durchschnitt eine hervorragende Leistung aufweisen.

• https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html

%%time
#Rastersuche, um die besten Parameter zu finden
from sklearn.model_selection import GridSearchCV

#Parameter zur Durchführung der Rastersuche (LogisticRegression-Parameter)
parameters = [
    {'solver': ['liblinear', 'saga'], 'penalty':['l1', 'l2'], 'C': [0.1, 1, 10, 100]},
    {'solver': ['newton-cg', 'sag', 'lbfgs' ], 'penalty':['l2'], 'C': [0.1, 1, 10, 100]},
]

#Ausführung der Rastersuche
classifier = GridSearchCV(LogisticRegression(), parameters, cv=3, n_jobs=-1)
classifier.fit(X_train, y_train)
print("Accuracy score (train): ", classifier.score(X_train, y_train))
print("Accuracy score (test): ", classifier.score(X_test, y_test))
print(classifier.best_estimator_) #Klassifikator mit den besten Parametern

Accuracy score (train):  0.784370477568741
Accuracy score (test):  0.6883116883116883
LogisticRegression(C=1, class_weight=None, dual=False, fit_intercept=True,
                   intercept_scaling=1, l1_ratio=None, max_iter=100,
                   multi_class='warn', n_jobs=None, penalty='l1',
                   random_state=None, solver='saga', tol=0.0001, verbose=0,
                   warm_start=False)
CPU times: user 192 ms, sys: 25.4 ms, total: 218 ms
Wall time: 2.52 s

Bewertungsindikatoren aufzeichnen und vergleichen

Von nun an möchte ich die Leistung verschiedener Methoden des maschinellen Lernens vergleichen. Bereiten wir daher eine Variable für die Aufzeichnung des Bewertungsindex vor.

scores = []

Es gibt verschiedene Indikatoren für die Leistung des Klassifizierungsmodells. Die wichtigsten sind wie folgt. Lassen Sie uns die Bedeutung von jedem überprüfen.

• https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html

• https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_score.html

• https://scikit-learn.org/stable/modules/generated/sklearn.metrics.recall_score.html

• https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html

• https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html

Ich habe eine Funktion erstellt, die diese Bewertungsindizes zusammen berechnet und in einer Variablen für die Aufzeichnung wie folgt speichert. Wiederholen Sie das Training und die Kreuzvalidierung für verschiedene Datenaufteilungen und zeichnen Sie deren durchschnittliche Leistung, Standardabweichung und Trainingszeit auf.

import timeit
from sklearn import metrics
def record_classification_scores(classifier_name, classifier, iter=5):
    records = []
    for run_id in range(iter):
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4) 
        print('Run ', run_id + 1)
        seconds = timeit.timeit(lambda: classifier.fit(X_train, y_train), number=1)
        print('    Learning Time (s):', seconds)
        y_pred = classifier.predict(X_test)
        y_proba = classifier.predict_proba(X_test)

        accuracy_score = metrics.accuracy_score(y_test, y_pred)
        precision_score = metrics.precision_score(y_test, y_pred)
        recall_score = metrics.recall_score(y_test, y_pred)
        f1_score = metrics.f1_score(y_test, y_pred)

        fpr, tpr, thresholds = roc_curve(y_test, y_proba[:, 1])
        roc_auc = auc(fpr, tpr)

        pre, rec, thresholds = precision_recall_curve(y_test, y_proba[:, 1])
        aupr = auc(rec, pre)
        
        mcc = metrics.matthews_corrcoef(y_test, y_pred)

        records.append([classifier_name, accuracy_score, precision_score, recall_score, 
                        f1_score, roc_auc, aupr, mcc, seconds])
    return records

Lassen Sie uns nun lernen, den zuvor erstellten "Klassifikator mit den besten Parametern" zu verwenden und den Leistungsindex aufzuzeichnen.

%%time
scores += record_classification_scores('LR', classifier.best_estimator_)

Run  1
    Learning Time (s): 0.004809510999990607
Run  2
    Learning Time (s): 0.004076423000000773
Run  3
    Learning Time (s): 0.004598837999992611
Run  4
    Learning Time (s): 0.004291107000000238
Run  5
    Learning Time (s): 0.003665049000005638
CPU times: user 65.8 ms, sys: 3.33 ms, total: 69.1 ms
Wall time: 67.6 ms

Die durchschnittliche Leistung und ihre Standardabweichung sind wie folgt.

df_scores = pd.DataFrame(scores, columns = ['Classifier', 'Accuracy', 'Precision', 'Recall', 
                                            'F1 score', 'ROC AUC', 'AUPR', 'MCC', 'Time'])
df_scores_mean = df_scores.iloc[:, :-1].mean()
df_scores_errors = df_scores.iloc[:, :-1].std()
df_scores_mean.plot(kind='bar', grid=True, yerr=df_scores_errors)

<matplotlib.axes._subplots.AxesSubplot at 0x7fd15943ca90>

Gradientenverstärkung

Gradient Boosting ist eine Technik, die in letzter Zeit an Aufmerksamkeit gewonnen hat. Ich werde hier nicht auf Details eingehen. Überprüfen Sie die erforderlichen Parameter auf der folgenden Website.

• https://scikit-learn.org/stable/modules/ensemble.html#gradient-tree-boosting

%%time
#Rastersuche, um die besten Parameter zu finden
from sklearn.model_selection import GridSearchCV

#Gradientenverstärkung
from sklearn.ensemble import GradientBoostingClassifier

#Parameter zur Durchführung der Rastersuche
parameters = [{
    'loss': ['deviance', 'exponential'],
    'learning_rate':[0.1,0.2],
    'n_estimators':[20,100,200],
    'max_depth':[3,5,7,9]
}]

#Ausführung der Rastersuche
classifier = GridSearchCV(GradientBoostingClassifier(), parameters, cv=3, n_jobs=-1)
classifier.fit(X_train, y_train)
print("Accuracy score (train): ", classifier.score(X_train, y_train))
print("Accuracy score (test): ", classifier.score(X_test, y_test))
print(classifier.best_estimator_) #Beste Parameter

Accuracy score (train):  1.0
Accuracy score (test):  0.7142857142857143
GradientBoostingClassifier(criterion='friedman_mse', init=None,
                           learning_rate=0.2, loss='deviance', max_depth=7,
                           max_features=None, max_leaf_nodes=None,
                           min_impurity_decrease=0.0, min_impurity_split=None,
                           min_samples_leaf=1, min_samples_split=2,
                           min_weight_fraction_leaf=0.0, n_estimators=100,
                           n_iter_no_change=None, presort='auto',
                           random_state=None, subsample=1.0, tol=0.0001,
                           validation_fraction=0.1, verbose=0,
                           warm_start=False)
CPU times: user 947 ms, sys: 25.1 ms, total: 973 ms
Wall time: 25.2 s

Lassen Sie uns die Leistung mit dem erhaltenen "Klassifikator mit den besten Parametern" lernen und aufzeichnen.

%%time
scores += record_classification_scores('GB', classifier.best_estimator_)

Run  1
    Learning Time (s): 0.3291641410000068
Run  2
    Learning Time (s): 0.31575948799999765
Run  3
    Learning Time (s): 0.3144692120000059
Run  4
    Learning Time (s): 0.3252903609999862
Run  5
    Learning Time (s): 0.3103595519999942
CPU times: user 1.64 s, sys: 7.28 ms, total: 1.65 s
Wall time: 1.65 s

Leistungsvergleichsergebnisanzeige mehrerer Methoden

Ich habe eine Funktion erstellt, um den Leistungsvergleich mehrerer Klassifizierungsmethoden zu visualisieren.

def visualize_classification_result(scores):
    df_scores = pd.DataFrame(scores, columns = ['Classifier', 'Accuracy', 'Precision', 'Recall', 
                                            'F1 score', 'ROC AUC', 'AUPR', 'MCC', 'Time'])
    df_scores_mean = df_scores.iloc[:, :-1].groupby('Classifier').mean()
    df_scores_errors = df_scores.iloc[:, :-1].groupby('Classifier').std()
    df_scores_mean.T.plot(kind='bar', grid=True, yerr=df_scores_errors.T, 
                          figsize=(12, 2), legend=False)
    plt.legend(loc = 'right', bbox_to_anchor = (0.7, 0.5, 0.5, 0.0))
    df_scores_mean.plot(kind='bar', grid=True, yerr=df_scores_errors, 
                        figsize=(12, 2), legend=False)
    plt.legend(loc = 'right', bbox_to_anchor = (0.7, 0.5, 0.5, 0.0))

    df_time_mean = df_scores.iloc[:, [0, -1]].groupby('Classifier').mean()
    df_time_errors = df_scores.iloc[:, [0, -1]].groupby('Classifier').std()
    df_time_mean.plot(kind='bar', grid=True, yerr=df_time_errors, 
                        figsize=(12, 2), legend=False)
    plt.yscale('log')

visualize_classification_result(scores)

Mehrschichtiges Perceptron

Multi-Layer Perceptron ist das einfachste Modell für Deep Learning und wird auch in Scikit-Learn implementiert.

Überprüfen Sie, welche Methoden und Parameter auf den folgenden Websites verfügbar sind.

• https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html

%%time
#Rastersuche, um die besten Parameter zu finden
from sklearn.model_selection import GridSearchCV

#Mehrschichtiges Perceptron
from sklearn.neural_network import MLPClassifier
#Parameter zur Durchführung der Rastersuche
parameters = [{'hidden_layer_sizes': [8, (8, 8), (8, 8, 8)], 
               'solver': ['sgd', 'adam', 'lbfgs'],
                     'activation': ['logistic', 'tanh', 'relu'],
              'learning_rate_init': [0.1, 0.01, 0.001]}]
#Ausführung der Rastersuche
classifier = GridSearchCV(MLPClassifier(max_iter=10000, early_stopping=True), 
                          parameters, cv=3, n_jobs=-1)
classifier.fit(X_train, y_train)
print("Accuracy score (train): ", classifier.score(X_train, y_train))
print("Accuracy score (test): ", classifier.score(X_test, y_test))
print(classifier.best_estimator_) #Klassifikator mit den besten Parametern

Accuracy score (train):  0.7930535455861071
Accuracy score (test):  0.7272727272727273
MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,
              beta_2=0.999, early_stopping=True, epsilon=1e-08,
              hidden_layer_sizes=8, learning_rate='constant',
              learning_rate_init=0.1, max_iter=10000, momentum=0.9,
              n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,
              random_state=None, shuffle=True, solver='lbfgs', tol=0.0001,
              validation_fraction=0.1, verbose=False, warm_start=False)
CPU times: user 1.15 s, sys: 39.8 ms, total: 1.19 s
Wall time: 2min 29s

Lassen Sie uns die Leistung mit dem erhaltenen "Klassifikator mit den besten Parametern" lernen und aufzeichnen.

%%time
scores += record_classification_scores('MLP', classifier.best_estimator_)

Run  1
    Learning Time (s): 0.4756240830000138
Run  2
    Learning Time (s): 0.34581674499997916
Run  3
    Learning Time (s): 0.15651393699999971
Run  4
    Learning Time (s): 0.14490434999999025
Run  5
    Learning Time (s): 0.005184319999955278
CPU times: user 1.16 s, sys: 3.54 ms, total: 1.17 s
Wall time: 1.17 s

Leistung vergleichen.

visualize_classification_result(scores)

Herausforderung 1

scikit-learn stellt den Brustkrebs-Datensatz als Trainingsdaten für maschinelles Lernen bereit. Teilen Sie den Datensatz wie folgt in erklärende Variablen und objektive Variablen ein, klassifizieren Sie Brustkrebsdaten mit MLPClassifier, während Sie Parameter mit GridSearchCV optimieren, und bewerten Sie die Leistung.

# https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_breast_cancer.html
from sklearn.datasets import load_breast_cancer
breast_cancer = load_breast_cancer()
X = pd.DataFrame(breast_cancer.data)
y = pd.DataFrame(breast_cancer.target.ravel())

Herausforderung 2

scikit-learn bietet einen Wein-Datensatz als Trainingsdaten für maschinelles Lernen. Teilen Sie den Datensatz wie folgt in erklärende Variablen und objektive Variablen ein, klassifizieren Sie Weindaten mit MLPClassifier, während Sie Parameter mit GridSearchCV optimieren, und bewerten Sie die Leistung.

# https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_wine.html
from sklearn.datasets import load_wine
wine = data = load_wine()
X = pd.DataFrame(wine.data)
y = pd.DataFrame(wine.target)

Da es sich bei dem Weindatensatz jedoch nicht um eine Zwei-Klassen-Klassifizierung wie den Brustkrebs-Datensatz handelt, sondern um eine Drei-Klassen-Klassifizierung, muss die Zielvariable wie folgt vorverarbeitet werden.

# https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html
import numpy as np
from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder(categories="auto", sparse=False, dtype=np.float32)
y = pd.DataFrame(encoder.fit_transform(y))

Wenn die Anzahl der MLP-Knoten (Anzahl der Neuronen) zu gering ist, ist die Klassifizierungsleistung gering. Erhöhen Sie daher die Anzahl der Knoten (Anzahl der Neuronen) entsprechend.

Rückgabeproblem

Nachdem wir das Klassifizierungsproblem gelöst haben, lösen wir das Regressionsproblem. Als Thema werden wir die Beziehung zwischen der Zusammensetzung und der Festigkeit von Beton diskutieren. Holen Sie sich zunächst die konkreten Daten.

Die Datenquelle ist der Concrete Slump Test-Datensatz https://archive.ics.uci.edu/ml/datasets/Concrete+Slump+Test.

#Importieren Sie eine Bibliothek, die den Zugriff auf Ressourcen per URL ermöglicht.
import urllib.request 
#Geben Sie Ressourcen im Web an
url = 'https://raw.githubusercontent.com/maskot1977/ipython_notebook/master/toydata/slump_test.data'
#Laden Sie die Ressource von der angegebenen URL herunter und geben Sie ihr einen Namen.
urllib.request.urlretrieve(url, 'slump_test.data') 

('slump_test.data', <http.client.HTTPMessage at 0x7ff02ed82518>)

import pandas as pd
df = pd.read_csv('slump_test.data', index_col=0)
df

Lesen wir die Erklärung der Datenquelle. Hier werden die linken 7 Spalten als erklärende Variablen und die Spalte ganz rechts als Zielvariable betrachtet.

X = df.iloc[:, :-3].apply(lambda x: (x-x.min())/(x.max() - x.min()), axis=0)
y = df.iloc[:, -1]

Teilen Sie in Trainingsdaten und Testdaten

#Importmethode zur Aufteilung in Trainingsdaten und Testdaten
from sklearn.model_selection import train_test_split 
#Zu Trainingsdaten / Testdaten 6:Zufällig geteilt durch ein Verhältnis von 4
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4)

Lineare multiple Regression

Versuchen wir das einfachste Regressionsmodell, die multiple lineare Regression.

from sklearn.linear_model import LinearRegression 
regressor = LinearRegression() #Lineare multiple Regression
regressor.fit(X_train, y_train) #Lernen

LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)

Leistungsbewertung des Regressionsmodells

Im Scikit-Learn-Regressionsmodell berechnet eine Methode namens .score () den Entscheidungsfaktor (R2-Wert). R2-Wert ist

• Nehmen Sie die Summe der Quadrate der Abweichung zwischen dem wahren Wert der Zielvariablen und dem vorhergesagten Wert.
• Teilen Sie es durch die Summe der Quadrate der Abweichung zwischen dem wahren Wert der Zielvariablen und ihrem Durchschnittswert.
• Subtrahiere es von 1.

Es wird so berechnet. Deshalb,

• Je kleiner die Abweichung des vorhergesagten Werts ist, desto näher nähert sich der R2-Wert 1.
• Wenn die Abweichung des vorhergesagten Werts groß wird und sich die Abweichung zwischen der Zielvariablen und ihrem Durchschnittswert nähert, nähert sich der R2-Wert 0.
• Wenn die Abweichung des vorhergesagten Werts größer wird als die Abweichung zwischen der Zielvariablen und ihrem Durchschnittswert, nimmt der R2-Wert einen negativen Wert an.

Es gibt eine Funktion.

Lassen Sie uns nun die Leistung mit dem Test-Set überprüfen, nachdem Sie mit dem Lehrer-Set gelernt haben.

regressor.score(X_train, y_train), regressor.score(X_test, y_test)

(0.9224703183565424, 0.8177828980042425)

Vorhersage von Daten, die nicht für das Training verwendet werden

Die Vorhersage kann durch Ersetzen von Daten, die nicht für das Training verwendet wurden, in das erhaltene Regressionsmodell erfolgen.

Das Diagramm der Zielvariablen und ihres vorhergesagten Werts wird üblicherweise als y-y-Diagramm bezeichnet (obwohl es nicht der offizielle Name zu sein scheint). Je diagonaler das Diagramm ist, desto besser ist das Regressionsmodell.

import numpy as np
import sklearn.metrics as metrics

y_pred = regressor.predict(X_test) #Ersatzdaten, die nicht für das Training verwendet werden

print("R2=", metrics.r2_score(y_test, y_pred))
print("RMSE=", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))
print("MAE=", metrics.mean_absolute_error(y_test, y_pred))

%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(4,4))
plt.scatter(y_test, y_pred, alpha=0.2, c="blue")
plt.plot([y.min(), y.max()], [y.min(), y.max()], c="black")
plt.grid()
plt.xlabel("Real Y")
plt.ylabel("Predicted Y")
plt.show()

R2= 0.8177828980042425
RMSE= 3.0139396734524633
MAE= 2.4622169354183447

Leistungsbewertung des Regressionsmodells

scikit-learn bietet Methoden zur Berechnung der folgenden Indikatoren für die Leistungsbewertung von Regressionsmodellen.

• sklearn.metrics.r2_score

• Der zuvor beschriebene R2-Wert. Ein Regressionsmodell, das einen größeren Wert annimmt (einen Wert, der näher an 1 liegt), ist ein besseres Modell.

  • https://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html

• sklearn.metrics.mean_squared_error

• Der durchschnittliche quadratische Fehler ist die Summe der Quadrate der Abweichung zwischen der Zielvariablen und dem vorhergesagten Wert. RMSE (Root Mean Square Error) ist die Quadratwurzel davon. Die Formeln ähneln der Varianz bzw. der Standardabweichung. Ein Regressionsmodell, das einen kleineren Wert (einen Wert näher an 0) annimmt, ist ein besseres Modell.

  • https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html

• sklearn.metrics.mean_absolute_error

• Der durchschnittliche absolute Fehler ist die Summe der absoluten Werte der Abweichung zwischen der Zielvariablen und dem vorhergesagten Wert. Da der durchschnittliche quadratische Fehler den Fehler quadriert, tendiert der durchschnittliche absolute Fehler dazu nicht, während er große Fehler hervorhebt. Ein Regressionsmodell, das einen kleineren Wert (einen Wert näher an 0) annimmt, ist ein besseres Modell.

  • https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_error.html

PLS (Partial Least Squares)

Partielle Regression im kleinsten Quadrat (PLS) ist eine Art lineare Regressionsmethode, die unter Verwendung von Variablen (latenten Variablen) zurückgibt, die linear aus erklärenden Variablen transformiert werden, so dass sie nicht miteinander korreliert sind. Im Vergleich zur normalen linearen multiplen Regression

• Da die erklärenden Variablen in latente Variablen umgewandelt werden, die nicht miteinander korreliert sind und zurückgegeben werden, tritt das Problem der Co-Linearität, dass die Regressionsebene schwer eindeutig zu bestimmen ist, wenn die Korrelation zwischen den erklärenden Variablen stark ist, nicht auf.
• Auch wenn die Anzahl der Stichproben kleiner als die erklärenden Variablen ist, können Sie zurückkehren, indem Sie alle erklärenden Variablen berücksichtigen, indem Sie die Anzahl der latenten Variablen reduzieren.
• Wenn nur die wichtigen latenten Variablen verwendet werden, kann Rauschen ausgeschlossen werden, das nicht zur Vorhersage beiträgt.

Es hat den Vorteil von.

#Importmethode zur Aufteilung in Trainingsdaten und Testdaten
from sklearn.model_selection import train_test_split 
#Zu Trainingsdaten / Testdaten 6:Zufällig geteilt durch ein Verhältnis von 4
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4)

from sklearn.cross_decomposition import PLSRegression #Methode zur Durchführung der PLS-Regression
regressor = PLSRegression() #Generierung von Abrufgeräten
regressor.fit(X_train, y_train) #Lernen

PLSRegression(copy=True, max_iter=500, n_components=2, scale=True, tol=1e-06)

import numpy as np
import sklearn.metrics as metrics

y_pred = regressor.predict(X_test)
print("R2=", metrics.r2_score(y_test, y_pred))
print("RMSE=", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))
print("MAE=", metrics.mean_absolute_error(y_test, y_pred))

%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(4,4))
plt.scatter(y_test, y_pred, alpha=0.2, c="blue")
plt.plot([y.min(), y.max()], [y.min(), y.max()], c="black")
plt.grid()
plt.xlabel("Real Y")
plt.ylabel("Predicted Y")
plt.show()

R2= 0.7649827980366806
RMSE= 3.523505754210429
MAE= 2.8524226793359198

Parametereinstellung durch Rastersuche

Lassen Sie uns die Parameter optimieren und ein besseres Modell erstellen.

%%time
#Rastersuche, um die besten Parameter zu finden
from sklearn.model_selection import GridSearchCV

#Parameter zur Durchführung der Rastersuche
parameters = [
    {'n_components': [2, 3, 4, 5, 6], 'scale':[True, False], 'max_iter': [1000]},
]

#Ausführung der Rastersuche
regressor = GridSearchCV(PLSRegression(), parameters, cv=3, n_jobs=-1)
regressor.fit(X_train, y_train)
print("R2 (train): ", regressor.score(X_train, y_train))
print("R2 (test): ", regressor.score(X_test, y_test))
print(regressor.best_estimator_) #Regressionsmodell mit besten Parametern

R2 (train):  0.9225247360485105
R2 (test):  0.8162623239997147
PLSRegression(copy=True, max_iter=1000, n_components=3, scale=False, tol=1e-06)
CPU times: user 114 ms, sys: 30.4 ms, total: 144 ms
Wall time: 2.18 s

Lassen Sie uns anhand des erhaltenen Regressionsmodells eine Vorhersage treffen. Hat sich die Vorhersageleistung verbessert?

import numpy as np
import sklearn.metrics as metrics

y_pred = regressor.predict(X_test)
print("R2=", metrics.r2_score(y_test, y_pred))
print("RMSE=", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))
print("MAE=", metrics.mean_absolute_error(y_test, y_pred))

%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(4,4))
plt.scatter(y_test, y_pred, alpha=0.2, c="blue")
plt.plot([y.min(), y.max()], [y.min(), y.max()], c="black")
plt.grid()
plt.xlabel("Real Y")
plt.ylabel("Predicted Y")
plt.show()

R2= 0.8162623239997147
RMSE= 3.115474987155132
MAE= 2.3005236909984426

Bewertungsindikatoren aufzeichnen und vergleichen

Von nun an möchte ich die Leistung verschiedener Regressionsmodelle vergleichen. Bereiten wir daher eine Variable für die Aufzeichnung des Bewertungsindex vor.

scores = []

Ich habe die folgende Funktion ausgeführt, um den Bewertungsindex des Regressionsmodells gemeinsam zu berechnen und in der Variablen für die Aufzeichnung zu speichern. Wiederholen Sie das Training und die Kreuzvalidierung für verschiedene Datenaufteilungen und zeichnen Sie deren durchschnittliche Leistung, Standardabweichung und Trainingszeit auf.

import timeit
import numpy as np
from sklearn import metrics

def record_regression_scores(regressor_name, regressor, iter=5):
    records = []
    run_id = 0
    successful = 0
    max_trial = 100
    while successful < iter:
        run_id += 1
        if run_id >= max_trial:
            break

        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4) 
        print('Run ', run_id)
        seconds = timeit.timeit(lambda: regressor.fit(X_train, y_train), number=1)
        print('    Learning Time (s):', seconds)
        y_pred = regressor.predict(X_test)
        r2_score = metrics.r2_score(y_test, y_pred)
        rmse_score = np.sqrt(metrics.mean_squared_error(y_test, y_pred))
        mae_score = metrics.mean_absolute_error(y_test, y_pred)

        if r2_score < 0:
            print("\t\t encountered negative r2_score")
            continue
        else:
            successful += 1

        records.append([regressor_name, r2_score, rmse_score, mae_score, seconds])
    return records

Lassen Sie uns nun lernen, das zuvor erstellte "Regressionsmodell mit den besten Parametern" zu verwenden und den Leistungsbewertungsindex aufzuzeichnen.

%%time
scores += record_regression_scores("PLS", regressor)

Run  1
    Learning Time (s): 2.0181297670001186
Run  2
    Learning Time (s): 1.9526900320001914
Run  3
    Learning Time (s): 1.9921050099997046
Run  4
    Learning Time (s): 2.0573012720001316
Run  5
    Learning Time (s): 1.979584856999736
CPU times: user 552 ms, sys: 101 ms, total: 653 ms
Wall time: 10 s

Die durchschnittliche Leistung und ihre Standardabweichung sind wie folgt.

df_scores = pd.DataFrame(scores, columns = ['Regressor', 'R2', 'RMSE', 'Mae', 'Time'])
df_scores_mean = df_scores.iloc[:, :-1].mean()
df_scores_errors = df_scores.iloc[:, :-1].std()
df_scores_mean.plot(kind='bar', grid=True, yerr=df_scores_errors)

<matplotlib.axes._subplots.AxesSubplot at 0x7ff0177f0550>

Gradientenverstärkung

Wir haben früher nach Gradientenverstärkung klassifiziert, aber Sie können auch nach Gradientenverstärkung zurückkehren.

#Importmethode zur Aufteilung in Trainingsdaten und Testdaten
from sklearn.model_selection import train_test_split 
#Zu Trainingsdaten / Testdaten 6:Zufällig geteilt durch ein Verhältnis von 4
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4)

from sklearn.ensemble import GradientBoostingRegressor
regressor = GradientBoostingRegressor() #Gradientenverstärkung
regressor.fit(X_train, y_train) #Lernen

GradientBoostingRegressor(alpha=0.9, criterion='friedman_mse', init=None,
                          learning_rate=0.1, loss='ls', max_depth=3,
                          max_features=None, max_leaf_nodes=None,
                          min_impurity_decrease=0.0, min_impurity_split=None,
                          min_samples_leaf=1, min_samples_split=2,
                          min_weight_fraction_leaf=0.0, n_estimators=100,
                          n_iter_no_change=None, presort='auto',
                          random_state=None, subsample=1.0, tol=0.0001,
                          validation_fraction=0.1, verbose=0, warm_start=False)

regressor.score(X_train, y_train), regressor.score(X_test, y_test)

(0.9996743754326906, 0.7386973055974495)

import numpy as np
import sklearn.metrics as metrics

y_pred = regressor.predict(X_test)

print("R2=", metrics.r2_score(y_test, y_pred))
print("RMSE=", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))
print("MAE=", metrics.mean_absolute_error(y_test, y_pred))

%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(4,4))
plt.scatter(y_test, y_pred, alpha=0.2, c="blue")
plt.plot([y.min(), y.max()], [y.min(), y.max()], c="black")
plt.grid()
plt.xlabel("Real Y")
plt.ylabel("Predicted Y")
plt.show()

R2= 0.7386973055974495
RMSE= 4.012901982806575
MAE= 3.0486670616108

%%time
#Rastersuche, um die besten Parameter zu finden
from sklearn.model_selection import GridSearchCV

#Gradientenverstärkung
from sklearn.ensemble import GradientBoostingRegressor

#Parameter zur Durchführung der Rastersuche
parameters = [{
    'learning_rate':[0.1,0.2],
    'n_estimators':[20,100],
    'max_depth':[3,5]
}]

#Ausführung der Rastersuche
regressor = GridSearchCV(GradientBoostingRegressor(), parameters, cv=3, n_jobs=-1)
regressor.fit(X_train, y_train)
print("R2 (train): ", regressor.score(X_train, y_train))
print("R2 (test): ", regressor.score(X_test, y_test))
print(regressor.best_estimator_) #Regressionsmodell mit besten Parametern

R2 (train):  0.9996743754326906
R2 (test):  0.7195388936429337
GradientBoostingRegressor(alpha=0.9, criterion='friedman_mse', init=None,
                          learning_rate=0.1, loss='ls', max_depth=3,
                          max_features=None, max_leaf_nodes=None,
                          min_impurity_decrease=0.0, min_impurity_split=None,
                          min_samples_leaf=1, min_samples_split=2,
                          min_weight_fraction_leaf=0.0, n_estimators=100,
                          n_iter_no_change=None, presort='auto',
                          random_state=None, subsample=1.0, tol=0.0001,
                          validation_fraction=0.1, verbose=0, warm_start=False)
CPU times: user 130 ms, sys: 15.4 ms, total: 145 ms
Wall time: 2.26 s

import numpy as np
import sklearn.metrics as metrics

y_pred = regressor.predict(X_test)
print("R2=", metrics.r2_score(y_test, y_pred))
print("RMSE=", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))
print("MAE=", metrics.mean_absolute_error(y_test, y_pred))

%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(4,4))
plt.scatter(y_test, y_pred, alpha=0.2, c="blue")
plt.plot([y.min(), y.max()], [y.min(), y.max()], c="black")
plt.grid()
plt.xlabel("Real Y")
plt.ylabel("Predicted Y")
plt.show()

R2= 0.7195388936429337
RMSE= 4.15741070004397
MAE= 3.0704656592653317

%%time
scores += record_regression_scores("GB", regressor.best_estimator_)

Run  1
    Learning Time (s): 0.027196151000225655
Run  2
    Learning Time (s): 0.01961764999987281
Run  3
    Learning Time (s): 0.01894888400011041
Run  4
    Learning Time (s): 0.019140249999964
Run  5
    Learning Time (s): 0.020592135999777383
CPU times: user 123 ms, sys: 2.75 ms, total: 126 ms
Wall time: 128 ms

Leistungsvergleichsergebnisanzeige mehrerer Methoden

Ich habe eine Funktion erstellt, um den Leistungsvergleich mehrerer Regressionsmethoden zu visualisieren.

def visualize_regression_result(scores):
    df_scores = pd.DataFrame(scores, columns =['Regressor', 'R2', 'RMSE', 'MAE', 'Time'])
    df_scores_mean = df_scores.iloc[:, :-1].groupby('Regressor').mean()
    df_scores_errors = df_scores.iloc[:, :-1].groupby('Regressor').std()
    df_scores_mean.T.plot(kind='bar', grid=True, yerr=df_scores_errors.T, 
                          figsize=(12, 2), legend=False)
    #plt.yscale('log')

    plt.legend(loc = 'right', bbox_to_anchor = (0.7, 0.5, 0.5, 0.0))
    df_scores_mean.plot(kind='bar', grid=True, yerr=df_scores_errors, 
                        figsize=(12, 2), legend=False)
    #plt.yscale('log')

    plt.legend(loc = 'right', bbox_to_anchor = (0.7, 0.5, 0.5, 0.0))
    df_time_mean = df_scores.iloc[:, [0, -1]].groupby('Regressor').mean()
    df_time_errors = df_scores.iloc[:, [0, -1]].groupby('Regressor').std()
    df_time_mean.plot(kind='bar', grid=True, yerr=df_time_errors, 
                        figsize=(12, 2), legend=False)
    plt.yscale('log')

visualize_regression_result(scores)

Mehrschichtiges Perceptron

Wir haben früher nach mehrschichtigem Perzeptron klassifiziert, aber Sie können auch nach mehrschichtigem Perzeptron zurückkehren.

#Importmethode zur Aufteilung in Trainingsdaten und Testdaten
from sklearn.model_selection import train_test_split 
#Zu Trainingsdaten / Testdaten 6:Zufällig geteilt durch ein Verhältnis von 4
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4)

from sklearn.neural_network import MLPRegressor
regressor = MLPRegressor() #Generierung von Abrufgeräten
regressor.fit(X_train, y_train) #Lernen

/usr/local/lib/python3.6/dist-packages/sklearn/neural_network/multilayer_perceptron.py:566: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.
  % self.max_iter, ConvergenceWarning)





MLPRegressor(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,
             beta_2=0.999, early_stopping=False, epsilon=1e-08,
             hidden_layer_sizes=(100,), learning_rate='constant',
             learning_rate_init=0.001, max_iter=200, momentum=0.9,
             n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,
             random_state=None, shuffle=True, solver='adam', tol=0.0001,
             validation_fraction=0.1, verbose=False, warm_start=False)

import numpy as np
import sklearn.metrics as metrics

y_pred = regressor.predict(X_test)
print("R2=", metrics.r2_score(y_test, y_pred))
print("RMSE=", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))
print("MAE=", metrics.mean_absolute_error(y_test, y_pred))

%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(4,4))
plt.scatter(y_test, y_pred, alpha=0.2, c="blue")
plt.plot([y.min(), y.max()], [y.min(), y.max()], c="black")
plt.grid()
plt.xlabel("Real Y")
plt.ylabel("Predicted Y")
plt.show()

R2= -4.0467411800805415
RMSE= 19.21649631146132
MAE= 17.449687389239205

%%time
#Rastersuche, um die besten Parameter zu finden
from sklearn.model_selection import GridSearchCV

#Parameter zur Durchführung der Rastersuche
parameters = [{
    'hidden_layer_sizes': [10, (10, 10)],
    'solver': ['sgd', 'adam', 'lbfgs'],
    #'solver': ['lbfgs'],
    #'activation': ['logistic', 'tanh', 'relu']
    'activation': ['relu']
}]

#Ausführung der Rastersuche
regressor = GridSearchCV(MLPRegressor(max_iter=10000, early_stopping=True), 
                         parameters, cv=3, n_jobs=-1)
regressor.fit(X_train, y_train)
print("R2 (train): ", regressor.score(X_train, y_train))
print("R2 (test): ", regressor.score(X_test, y_test))
print(regressor.best_estimator_) #Regressionsmodell mit besten Parametern

R2 (train):  0.9742637037080083
R2 (test):  0.9562295568855493
MLPRegressor(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,
             beta_2=0.999, early_stopping=True, epsilon=1e-08,
             hidden_layer_sizes=(10, 10), learning_rate='constant',
             learning_rate_init=0.001, max_iter=10000, momentum=0.9,
             n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,
             random_state=None, shuffle=True, solver='lbfgs', tol=0.0001,
             validation_fraction=0.1, verbose=False, warm_start=False)
CPU times: user 222 ms, sys: 17.5 ms, total: 239 ms
Wall time: 7.86 s

import numpy as np
import sklearn.metrics as metrics

y_pred = regressor.predict(X_test)
print("R2=", metrics.r2_score(y_test, y_pred))
print("RMSE=", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))
print("MAE=", metrics.mean_absolute_error(y_test, y_pred))

%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(4,4))
plt.scatter(y_test, y_pred, alpha=0.2, c="blue")
plt.plot([y.min(), y.max()], [y.min(), y.max()], c="black")
plt.grid()
plt.xlabel("Real Y")
plt.ylabel("Predicted Y")
plt.show()

R2= 0.9562295568855493
RMSE= 1.789613149534058
MAE= 1.3873465536350154

%%time
scores += record_regression_scores("MLP", regressor.best_estimator_)

Run  1
    Learning Time (s): 0.06779548599979535
Run  2
    Learning Time (s): 0.1298420270004499
Run  3
    Learning Time (s): 0.1824235089998183
Run  4
    Learning Time (s): 0.43246253200004503
Run  5
    Learning Time (s): 0.22879209799975797
CPU times: user 1.06 s, sys: 3.13 ms, total: 1.06 s
Wall time: 1.07 s

visualize_regression_result(scores)

Übung 3

scikit-learn stellt den Diabetes-Datensatz als Trainingsdaten für maschinelles Lernen bereit. Teilen Sie den Datensatz wie folgt in erklärende Variablen und objektive Variablen ein und vergleichen Sie die Leistung, indem Sie die Diabetesdaten mit MLPRegressor oder GradientBoostingRegressor zurückziehen, während Sie die Parameter mit GridSearchCV optimieren.

# https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_diabetes.html
from sklearn.datasets import load_diabetes
diabetes = load_diabetes()
X = diabetes.data
y = diabetes.target