#01 | Maschinelles Lernen mit der linearen Regression

Tauchen Sie ein in die Essenz des maschinellen Lernens, indem Sie mehrere Regressionsmodelle mit einem praktischen Anwendungsfall in Python entwickeln, um Unfälle in den USA vorherzusagen.

Lesen Sie den Originalartikel hierin Hashnode.

🎯 Kapitelwichtigkeit

Beim maschinellen Lernen dreht sich alles ums Rechnen die besten Zahlen einer mathematischen Gleichung durch Minimierung der Distanz zwischen realen Daten und Vorhersagen.

Die Form einer mathematischen Gleichung für eine lineare Regression lautet wie folgt:

j=(a)+(b)xy = (a) + (b) \cdot x

Wie wir in der folgenden Handlung sehen, keine mathematische Gleichung ist gültig; Die rote Linie passt nicht zu den realen Daten (blaue Punkte), während die grüne die beste ist.

lineare-regression.jpeg

Wie verstehen wir die Entwicklung von Machine-Learning-Modellen in Python? um vorherzusagen, was in der Zukunft passieren könnte?

Dieses Tutorial behandelt die unten beschriebenen Themen mit Daten zu Autounfällen in den USA um die Unfälle auf Alkoholbasis vorherzusagen.

  1. Schritt-für-Schritt-Verfahren zur Berechnung einer linearen Regression:
    1. .fit() die Zahlen der mathematischen Gleichung
    2. .predict() die Zukunft mit der mathematischen Gleichung
    3. .score() wie gut ist die mathematische gleichung
  2. Wie man visualisieren das lineare Regressionsmodell?
  3. Wie man auswerten Regressionsmodelle Schritt für Schritt?
    • Residuen Quadratsumme
    • Gesamtsumme der Quadrate
    • R-Quadrat-Verhältnis
      R2R^2

  4. Wie man interpretieren die Koeffizienten der linearen Regression?
  5. Vergleichen Sie die lineare Regression mit anderen Machine-Learning-Modellen wie:
    • Zufälliger Wald
    • Support-Vektor-Maschinen
  6. Warum wir brauchen keine mathekenntnisse hinter jedem Modell, um maschinelles Lernen in Python anzuwenden?

💽 Laden Sie die Daten

  • Dieser Datensatz enthält Statistiken über Autounfälle (Säulen)
  • In jedem von USA-Staaten (Reihen)

Besuch Diese Internetseite wenn Sie die Maße der Säulen wissen wollen.

import seaborn as sns 

df_crashes = sns.load_dataset(name='car_crashes', index_col='abbrev')[['alcohol', 'total']]
df_crashes.rename({'total': 'accidents'}, axis=1, inplace=True)
df_crashes

df1.jpeg

🤖 Wie berechnen wir ein lineares Regressionsmodell in Python?

  • Wie immer müssen wir eine Funktion verwenden

Wo ist die Funktion?

  • Es sollte in einer Bibliothek sein

Welches ist die Python-Bibliothek für maschinelles Lernen?

Importieren Sie die Klasse

Wie können wir auf die Funktion zugreifen, um ein lineares Regressionsmodell zu berechnen?

  • Wir müssen die importieren LinearRegression Klasse drin linear_model Modul:
from sklearn.linear_model import LinearRegression

Instanziieren Sie die Klasse

  • Jetzt erstellen wir eine Instanz model_lr der Klasse LinearRegression:
model_lr = LinearRegression()

Passen Sie das Modell an

Welche Funktion wendet die lineare Regression an Algorithmus in dem die Die Residuensumme der Quadrate wird minimiert?

model_lr.fit()
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Input In [186], in <cell line: 1>()
----> 1 model_lr.fit()


TypeError: fit() missing 2 required positional arguments: 'X' and 'y'

Warum fragt es nach zwei Parametern: y und X?

Der Algorithmus muss zwischen der Variablen unterscheiden, die wir vorhersagen möchten (y) und die Variablen zur Erklärung von (X) Die Vorhersage.

  • y: Ziel ~ unabhängig ~ Label ~ Klassenvariable
  • X: verfügt über ~ abhängige ~ erklärende Variablen

Trennen Sie die Variablen

target = df_crashes['accidents']
features = df_crashes[['alcohol']]

Passen Sie das Modell erneut an

model_lr.fit(X=features, y=target)
LinearRegression()

Vorhersagen

Berechnen Sie die Vorhersagen

Nehmen Sie die historischen Daten:

features

df2.jpeg

Vorhersagen durch die mathematische Gleichung des Modells berechnen:

model_lr.predict(X=features)
array([17.32111171, 15.05486718, 16.44306899, 17.69509287, 12.68699734,
       13.59756016, 13.76016066, 15.73575679,  9.0955587 , 16.40851638,
       13.78455074, 20.44100889, 14.87600663, 14.70324359, 14.40446516,
       13.8353634 , 14.54064309, 15.86177218, 19.6076813 , 15.06502971,
       13.98780137, 11.69106925, 13.88211104, 11.5162737 , 16.94713055,
       16.98371566, 24.99585551, 16.45729653, 15.41868581, 12.93089809,
       12.23171592, 15.95526747, 13.10772614, 16.44306899, 26.26007443,
       15.60161138, 17.58737003, 12.62195713, 17.32517672, 14.43088774,
       25.77430543, 18.86988151, 17.3515993 , 20.84141263,  9.53254755,
       14.15040187, 12.82724027, 12.96748321, 19.40239816, 15.11380986,
       17.17477126])

Fügen Sie eine neue Spalte mit den Vorhersagen hinzu

Sehen Sie den Unterschied zwischen Realität und Vorhersage?

  • Modellvorhersagen sind nicht perfekt; Sie sagen die realen Daten nicht genau voraus. Dennoch stellen sie eine faire Annäherung dar, die es Entscheidungsträgern ermöglicht, die Zukunft besser zu verstehen.
df_crashes['pred_lr'] = model_lr.predict(X=features)
df_crashes

df3.jpeg

Modellvisualisierung

Die orangefarbenen Punkte verweisen auf die in einer Linie aufgereihten Vorhersagen, da das lineare Regressionsmodell die besten Koeffizienten (Zahlen) für die mathematische Gleichung einer Linie basierend auf historischen Daten berechnet.

import matplotlib.pyplot as plt
sns.scatterplot(x='alcohol', y='accidents', data=df_crashes)
sns.scatterplot(x='alcohol', y='pred_lr', data=df_crashes);

plot1.jpeg

Wir haben orangefarbene Punkte für den Alkohol, der in unserem vertreten ist DataFrame. Würden wir Schätzungen über alle möglichen Alkoholzahlen vornehmen, kämen wir auf a Folge aufeinanderfolgender Punkte, die eine Linie darstellte. Zeichnen wir es mit .lineplot() Funktion:

sns.scatterplot(x='alcohol', y='accidents', data=df_crashes)
sns.scatterplot(x='alcohol', y='pred_lr', data=df_crashes);
sns.lineplot(x='alcohol', y='pred_lr', data=df_crashes, color='orange');

plot2.jpeg

Bewertung des Modells

Berechnen Sie die Punktzahl

Um die Qualität des Modells zu messen, verwenden wir die .score() Funktion, um die Differenz zwischen den Vorhersagen des Modells und der Realität korrekt zu berechnen.

model_lr.score(X=features, y=target)
0.7269492966665405

Erklären Sie die Partitur

Reste

Das Schritt-für-Schritt-Verfahren der vorherigen Berechnung beginnt mit der Differenz zwischen Realität und Prognose:

df_crashes['accidents'] - df_crashes['pred_lr']
abbrev
AL    1.478888
AK    3.045133
        ...   
WI   -1.313810
WY    0.225229
Length: 51, dtype: float64

Dieser Unterschied wird üblicherweise als Reste:

df_crashes['residuals'] = df_crashes['accidents'] - df_crashes['pred_lr']
df_crashes

df4.jpeg

Wir können nicht alle Residuen verwenden, um zu sagen, wie gut unser Modell ist. Daher müssen wir sie addieren:

df_crashes.residuals.sum()
1.4033219031261979e-13

Runden wir auf zwei Dezimalstellen, um die wissenschaftliche Schreibweise zu unterdrücken:

df_crashes.residuals.sum().round(2)
0.0

Aber wir bekommen NULL. Wieso den?

Die Residuen enthalten positive und negative Zahlen; Einige Punkte liegen oberhalb der Linie, andere unterhalb der Linie.

Um negative Werte in positive Werte umzuwandeln, quadrieren wir die Residuen:

df_crashes['residuals^2'] = df_crashes.residuals**2
df_crashes

df5.jpeg

Und schließlich addieren Sie die Residuen, um die zu berechnen Residualsumme der Quadrate (RSS):

df_crashes['residuals^2'].sum()
231.96888653310063
RSS = df_crashes['residuals^2'].sum()

RSS=(jichj^)2RSS = \sum(y_i – \hat{y})^2

wo

  • y_i ist die tatsächliche Zahl der Unfälle

  • j^\hat y

  • RSS: Residualsumme der Quadrate
Variation des Ziels

Das Modell wurde erstellt, um die Anzahl der Unfälle vorherzusagen.

Wir sollten fragen: Wie gut sind die Variationen der Vorhersagen des Modells im Vergleich zu den Variationen der realen Daten (reale Anzahl von Unfällen)?

Wir haben bereits die Variation der Modellvorhersage berechnet. Jetzt berechnen wir die Abweichung der realen Daten, indem wir jeden Unfallwert mit dem Durchschnitt vergleichen:

df_crashes.accidents
abbrev
AL    18.8
AK    18.1
      ... 
WI    13.8
WY    17.4
Name: accidents, Length: 51, dtype: float64
df_crashes.accidents.mean()
15.79019607843137

xichx¯x_i – \bar x

Wobei x die Anzahl der Unfälle ist

df_crashes.accidents - df_crashes.accidents.mean()
abbrev
AL    3.009804
AK    2.309804
        ...   
WI   -1.990196
WY    1.609804
Name: accidents, Length: 51, dtype: float64
df_crashes['real_residuals'] = df_crashes.accidents - df_crashes.accidents.mean()
df_crashes

df6.jpeg

Wir quadrieren die fälligen Residuen aus dem gleichen Grund wie zuvor (wandeln negative Werte in positive um):

df_crashes['real_residuals^2'] = df_crashes.real_residuals**2

TTS=(jichj¯)2TTS = \sum(y_i – \bar y)^2

wo

  • y_i ist die Anzahl der Unfälle

  • j¯\bar und

  • TTS: Gesamtsumme der Quadrate

Und wir addieren die Werte, um die zu erhalten Summe der Quadrate (RSS):

df_crashes['real_residuals^2'].sum()
849.5450980392156
TSS = df_crashes['real_residuals^2'].sum()
Das Verhältnis

Das Verhältnis zwischen RSS und TSS stellt dar, wie sehr unser Modell hinsichtlich der Streuung der realen Daten versagt.

RSS/TSS
0.2730507033334595

0,27 ist die Schlechtigkeit des Modells als RSS repräsentiert die Reste (Fehler) des Modells.

Zur Berechnung der Güte des Modells müssen wir das Verhältnis RSS/TSS zu 1 subtrahieren:

R2=1RSSTSS=1(jichj^)2(jichj¯)2R^2 = 1 – \frac{RSS}{TSS} = 1 – \frac{\sum(y_i – \hat{y})^2}{\sum(y_i – \bar y)^2}

1 - RSS/TSS
0.7269492966665405

Das Modell kann 72,69 % der Gesamtunfallvariabilität erklären.

Das folgende Bild beschreibt, wie wir die Güte des Modells berechnen.

Modellinterpretation

Wie erhalten wir die Zahlen der mathematischen Gleichung der linearen Regression?

  • Wir müssen in das Objekt hineinschauen model_lr und zeige die Attribute mit an .__dict__ (Die Zahlen wurden mit dem berechnet .fit() Funktion):
model_lr.__dict__
{'fit_intercept': True,
 'normalize': 'deprecated',
 'copy_X': True,
 'n_jobs': None,
 'positive': False,
 'feature_names_in_': array(['alcohol'], dtype=object),
 'n_features_in_': 1,
 'coef_': array([2.0325063]),
 '_residues': 231.9688865331006,
 'rank_': 1,
 'singular_': array([12.22681605]),
 'intercept_': 5.857776154826299}
  • intercept_ ist die (a) Zahl der mathematischen Gleichung
  • coef_ die (b) Zahl der mathematischen Gleichung ist

Unfälle = (a) + (b) \cdot Alkohol \\ Unfälle = (Achsenabschnitt\_) + (coef\_) \cdot Alkohol \\ Unfälle = (5,857) + (2,032) \cdot Alkohol

Für jede erhöhte Alkoholeinheit erhöht sich die Zahl der Unfälle um 2.032 Einheiten.

import pandas as pd

df_to_pred = pd.DataFrame({'alcohol': [1,2,3,4,5]})
df_to_pred['pred_lr'] = 5.857 + 2.032 * df_to_pred.alcohol
df_to_pred['diff'] = df_to_pred.pred_lr.diff()
df_to_pred

df7.jpeg

🚀 Andere Regressionsmodelle

Könnten wir ein besseres Modell erstellen, das den aktuellen Linear Regression Score verbessert?

model_lr.score(X=features, y=target)
0.7269492966665405
  • Versuchen wir es mit einem Random Forest und einer Support Vector Machine.

Müssen wir die Mathematik hinter diesen Modellen kennen, um sie in Python zu implementieren?

RandomForestRegressor() in Python

Passen Sie das Modell an

from sklearn.ensemble import RandomForestRegressor

model_rf = RandomForestRegressor()
model_rf.fit(X=features, y=target)
RandomForestRegressor()

Vorhersagen berechnen

model_rf.predict(X=features)
array([18.644     , 16.831     , 17.54634286, 21.512     , 12.182     ,
       13.15      , 12.391     , 17.439     ,  7.775     , 17.74664286,
       14.407     , 18.365     , 15.101     , 14.132     , 13.553     ,
       15.097     , 15.949     , 19.857     , 21.114     , 15.53      ,
       13.241     ,  8.98      , 14.363     ,  9.54      , 17.208     ,
       16.593     , 22.087     , 16.24144286, 14.478     , 11.51      ,
       11.59      , 18.537     , 11.77      , 17.54634286, 23.487     ,
       14.907     , 20.462     , 12.59      , 18.38      , 12.449     ,
       23.487     , 20.311     , 19.004     , 19.22      ,  9.719     ,
       13.476     , 12.333     , 11.08      , 22.368     , 14.67      ,
       17.966     ])
df_crashes['pred_rf'] = model_rf.predict(X=features)

Bewertung des Modells

model_rf.score(X=features, y=target)
0.9549469198566546

Lassen Sie uns ein Wörterbuch erstellen, das den Score jedes Modells speichert:

dic_scores = {}
dic_scores['lr'] = model_lr.score(X=features, y=target)
dic_scores['rf'] = model_rf.score(X=features, y=target)

SVR() in Python

Passen Sie das Modell an

from sklearn.svm import SVR

model_sv = SVR()
model_sv.fit(X=features, y=target)
SVR()

Vorhersagen berechnen

model_sv.predict(X=features)
array([18.29570777, 15.18462721, 17.2224187 , 18.6633175 , 12.12434781,
       13.10691581, 13.31612684, 16.21131216, 12.66062465, 17.17537208,
       13.34820949, 19.38920329, 14.91415215, 14.65467023, 14.2131504 ,
       13.41560202, 14.41299448, 16.39752499, 19.4896662 , 15.20002787,
       13.62200798, 11.5390483 , 13.47824339, 11.49818909, 17.87053595,
       17.9144274 , 19.60736085, 17.24170425, 15.73585463, 12.35136579,
       11.784815  , 16.53431108, 12.53373232, 17.2224187 , 19.4773929 ,
       16.01115736, 18.56379706, 12.06891287, 18.30002795, 14.25171609,
       19.59597679, 19.37950461, 18.32794218, 19.29994413, 12.26345665,
       13.84847453, 12.25128025, 12.38791686, 19.48212198, 15.27397732,
       18.1357253 ])
df_crashes['pred_sv'] = model_sv.predict(X=features)

Bewertung des Modells

model_sv.score(X=features, y=target)
0.7083438012012769
dic_scores['sv'] = model_sv.score(X=features, y=target)

💪 Welches ist das Beste? Wieso den?

Das beste Modell ist der Random Forest mit einem Score von 0,95:

pd.Series(dic_scores).sort_values(ascending=False)
rf    0.954947
lr    0.726949
sv    0.708344
dtype: float64

📊 Visualisieren Sie die 3 Modelle

Lassen Sie uns die folgenden Daten eingeben:

df_crashes[['accidents', 'pred_lr', 'pred_rf', 'pred_sv']]

df8.jpeg

In eine Handlung:

sns.scatterplot(x='alcohol', y='accidents', data=df_crashes, label='Real Data')
sns.scatterplot(x='alcohol', y='pred_lr', data=df_crashes, label='Linear Regression')
sns.lineplot(x='alcohol', y='pred_lr', data=df_crashes, color='orange')
sns.scatterplot(x='alcohol', y='pred_rf', data=df_crashes, label='Random Forest')
sns.scatterplot(x='alcohol', y='pred_sv', data=df_crashes, label='Support Vector Machines');

plot3.jpeg

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *