ML-For-Beginners/translations/de/2-Regression/3-Linear

Erstelle ein Regressionsmodell mit Scikit-learn: Regression auf vier Arten

Anmerkung für Anfänger

Lineare Regression wird verwendet, wenn wir einen numerischen Wert vorhersagen möchten (zum Beispiel Hauspreis, Temperatur oder Umsatz). Sie funktioniert, indem sie eine Gerade findet, die die Beziehung zwischen Eingabemerkmalen und Ausgabe bestmöglich darstellt.

In dieser Lektion konzentrieren wir uns darauf, das Konzept zu verstehen, bevor wir fortgeschrittenere Regressionstechniken erkunden.

Infografik von Dasani Madipalli

Vorlesungsquiz

Diese Lektion ist auch in R verfügbar!

Einführung

Bis jetzt hast du erkundet, was Regression ist, anhand von Beispieldaten aus dem Kürbis-Preis-Datensatz, den wir in dieser Lektion verwenden werden. Du hast ihn auch mit Matplotlib visualisiert.

Jetzt bist du bereit, tiefer in Regression für ML einzutauchen. Während die Visualisierung dabei hilft, die Daten zu verstehen, liegt die wahre Stärke von Machine Learning im Trainieren von Modellen. Modelle werden auf historischen Daten trainiert, um Datenabhängigkeiten automatisch zu erfassen, und ermöglichen es, Vorhersagen für neue Daten zu machen, die das Modell vorher nicht gesehen hat.

In dieser Lektion lernst du mehr über zwei Arten der Regression: einfache lineare Regression und polynomiale Regression sowie einige der Mathematik, die diesen Techniken zugrunde liegt. Diese Modelle werden uns erlauben, Kürbisse je nach unterschiedlichen Eingabedaten vorherzusagen.

🎥 Klicke auf das Bild oben für eine kurze Videoübersicht zur linearen Regression.

Im gesamten Lehrplan gehen wir von minimalen mathematischen Vorkenntnissen aus und möchten es für Studierende aus anderen Fachrichtungen zugänglich machen. Achte also auf Anmerkungen, 🧮 Hervorhebungen, Diagramme und andere Lernhilfen zur Unterstützung des Verständnisses.

Voraussetzungen

Du solltest jetzt mit der Struktur der Kürbisdaten vertraut sein, die wir untersuchen. Du findest sie vorab geladen und bereinigt in der Datei notebook.ipynb dieser Lektion. Dort wird der Kürbisp steht pro Bushel in einem neuen DataFrame angezeigt. Stelle sicher, dass du diese Notebooks in Visual Studio Code in passenden Umgebungen ausführen kannst.

Vorbereitung

Zur Erinnerung: Du lädst diese Daten, um Fragen an sie stellen zu können.

• Wann ist die beste Zeit, Kürbisse zu kaufen?
• Welchen Preis kann ich für eine Kiste mit Mini-Kürbissen erwarten?
• Sollte ich sie in halben Bushel-Körben oder im 1 1/9 Bushel-Karton kaufen? Lass uns weiter in diese Daten eintauchen.

In der vorherigen Lektion hast du ein Pandas DataFrame erstellt und mit einem Teil des ursprünglichen Datensatzes gefüllt, wobei die Preise pro Bushel standardisiert wurden. Dadurch konntest du jedoch nur etwa 400 Datenpunkte und nur für die Herbstmonate erfassen.

Betrachte die Daten, die wir in dem Notebook dieser Lektion vorab geladen haben. Die Daten sind vorab geladen und ein erster Streudiagramm wird gezeichnet, um Monatsdaten zu zeigen. Vielleicht können wir mehr Details über die Natur der Daten erhalten, wenn wir sie weiter bereinigen.

Eine Linie der linearen Regression

Wie du in Lektion 1 gelernt hast, ist das Ziel einer linearen Regression, eine Linie zu zeichnen, um:

• Variablenbeziehungen zu zeigen. Die Beziehung zwischen Variablen darstellen
• Vorhersagen zu machen. Genau vorhersagen, wo ein neuer Datenpunkt in Bezug auf diese Linie liegen würde.

Typisch für die Methode der kleinsten Quadrate ist es, diese Art von Linie zu zeichnen. Der Begriff "Methode der kleinsten Quadrate" bezieht sich auf den Prozess, den Gesamtfehler in unserem Modell zu minimieren. Für jeden Datenpunkt messen wir den vertikalen Abstand (genannt Residuum) zwischen dem tatsächlichen Punkt und unserer Regressionslinie.

Wir quadrieren diese Abstände aus zwei Hauptgründen:

1. Betrag statt Richtung: Wir möchten einen Fehler von -5 genauso behandeln wie einen Fehler von +5. Das Quadrieren macht alle Werte positiv.

2. Bestrafung von Ausreißern: Das Quadrieren gibt größeren Fehlern mehr Gewicht, wodurch die Linie gezwungen wird, näher an weit entfernten Punkten zu bleiben.

Dann addieren wir alle quadrierten Werte zusammen. Unser Ziel ist es, genau die Linie zu finden, bei der diese Summe am geringsten ist – daher der Name "Methode der kleinsten Quadrate".

🧮 Zeig mir die Mathematik

Diese Linie, genannt Line of Best Fit, kann durch eine Gleichung ausgedrückt werden:

Y = a + bX

X ist die „erklärende Variable“. Y ist die „abhängige Variable“. Die Steigung der Linie ist b und a ist der y-Achsenabschnitt, also der Wert von Y, wenn X = 0 ist.

Zuerst berechne die Steigung b. Infografik von Jen Looper

Anders ausgedrückt, und bezogen auf die ursprüngliche Frage unserer Kürbisdaten: "Vorhersage des Preises eines Kürbisses pro Bushel nach Monat", würde X den Preis darstellen und Y den Verkaufsmonat.

Berechne den Wert von Y. Wenn du etwa $4 zahlst, muss es April sein! Infografik von Jen Looper

Die Rechnung, die die Linie berechnet, muss die Steigung der Linie zeigen, die auch vom Achsenabschnitt abhängt, also von dem Punkt, an dem Y liegt, wenn X = 0 ist.

Du kannst die Berechnungsmethode für diese Werte auf der Website Math is Fun nachlesen. Besuche auch diesen Least-Squares-Rechner, um zu sehen, wie die Werte die Linie beeinflussen.

Korrelation

Ein weiterer Begriff, den du verstehen solltest, ist der Korrelationskoeffizient zwischen bestimmten X- und Y-Variablen. Mit einem Streudiagramm kannst du diesen Koeffizienten schnell visualisieren. Ein Diagramm mit Datenpunkten, die sich in einer geordneten Linie anordnen, hat eine hohe Korrelation, während ein Diagramm mit verstreuten Punkten zwischen X und Y eine niedrige Korrelation aufweist.

Ein gutes lineares Regressionsmodell hat einen hohen (näher bei 1 als bei 0) Korrelationskoeffizienten, wenn die Methode der kleinsten Quadrate mit einer Regressionslinie verwendet wird.

✅ Führe das zu dieser Lektion gehörende Notebook aus und sieh dir das Streudiagramm Monat zu Preis an. Hat die Datenzuordnung von Monat zu Preis für Kürbisverkäufe deiner visuellen Interpretation nach eine hohe oder niedrige Korrelation? Ändert sich das, wenn du statt Monat eine feinere Maßeinheit wie Tag des Jahres (z.B. Anzahl der Tage seit Jahresbeginn) verwendest?

Im folgenden Code gehen wir davon aus, dass wir die Daten bereinigt und einen DataFrame mit dem Namen new_pumpkins erhalten haben, ähnlich dem Folgenden:

ID	Monat	TagDesJahres	Sorte	Stadt	Verpackung	Niedriger Preis	Hoher Preis	Preis
70	9	267	PIE TYPE	BALTIMORE	1 1/9 Bushel Kartons	15.0	15.0	13.636364
71	9	267	PIE TYPE	BALTIMORE	1 1/9 Bushel Kartons	18.0	18.0	16.363636
72	10	274	PIE TYPE	BALTIMORE	1 1/9 Bushel Kartons	18.0	18.0	16.363636
73	10	274	PIE TYPE	BALTIMORE	1 1/9 Bushel Kartons	17.0	17.0	15.454545
74	10	281	PIE TYPE	BALTIMORE	1 1/9 Bushel Kartons	15.0	15.0	13.636364

Der Code zum Bereinigen der Daten ist in notebook.ipynb verfügbar. Wir haben die gleichen Bereinigungsschritte wie in der vorherigen Lektion durchgeführt und die Spalte DayOfYear mit folgendem Ausdruck berechnet:

day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)

Nachdem du die Mathematik hinter der linearen Regression verstanden hast, erstellen wir nun ein Regressionsmodell, um zu sehen, ob wir vorhersagen können, welches Kürbis-Paket die besten Preise hat. Jemand, der Kürbisse für einen Feiertag-Kürbisgarten kauft, möchte diese Information möglicherweise nutzen, um seine Kürbiskäufe zu optimieren.

Suche nach Korrelation

🎥 Klicke auf das Bild oben für eine kurze Videoübersicht über Korrelation.

Aus der vorherigen Lektion hast du wahrscheinlich gesehen, dass der Durchschnittspreis für verschiedene Monate so aussieht:

Das deutet darauf hin, dass es eine Korrelation geben sollte, und wir können versuchen, ein lineares Regressionsmodell zu trainieren, um die Beziehung zwischen Monat und Preis oder zwischen DayOfYear und Preis vorherzusagen. Hier ist das Streudiagramm, das die letztere Beziehung zeigt:

Sehen wir uns die Korrelation mit der corr Funktion an:

print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))

Es scheint, dass die Korrelation ziemlich gering ist, -0,15 bei Monat und -0,17 bei DayOfYear, aber es könnte eine andere wichtige Beziehung geben. Es sieht so aus, als gäbe es verschiedene Preiscluster, die unterschiedlichen Kürbissorten entsprechen. Um diese Hypothese zu bestätigen, zeichnen wir jede Kürbiskategorie mit einer anderen Farbe. Indem wir der scatter Funktion einen ax Parameter übergeben, können wir alle Punkte im gleichen Diagramm darstellen:

ax=None
colors = ['red','blue','green','yellow']
for i,var in enumerate(new_pumpkins['Variety'].unique()):
    df = new_pumpkins[new_pumpkins['Variety']==var]
    ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)

Unsere Untersuchung legt nahe, dass die Sorte mehr Einfluss auf den Gesamtpreis hat als das tatsächliche Verkaufsdatum. Das können wir mit einem Balkendiagramm sehen:

new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')

Konzentrieren wir uns nun nur auf eine Kürbissorte, den 'Pie Type', und sehen uns den Einfluss des Datums auf den Preis an:

pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price') 

Wenn wir jetzt die Korrelation zwischen Preis und DayOfYear mit der corr Funktion berechnen, erhalten wir ungefähr -0,27 – was bedeutet, dass es sinnvoll ist, ein Vorhersagemodell zu trainieren.

Bevor du ein lineares Regressionsmodell trainierst, ist es wichtig sicherzustellen, dass unsere Daten sauber sind. Lineare Regression funktioniert schlecht mit fehlenden Werten, daher ist es sinnvoll, leere Zellen zu entfernen:

pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()

Eine andere Möglichkeit wäre, diese leeren Werte mit Mittelwerten der jeweiligen Spalte zu füllen.

Einfache lineare Regression

🎥 Klicke auf das Bild oben für eine kurze Videoübersicht zu linearer und polynomialer Regression.

Um unser Modell der linearen Regression zu trainieren, verwenden wir die Scikit-learn-Bibliothek.

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split

Wir beginnen, indem wir Eingabewerte (Features) und die erwartete Ausgabe (Label) in getrennte Numpy-Arrays aufteilen:

X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']

Beachte, dass wir die Eingabedaten mittels reshape umformen mussten, damit das Linear Regression-Paket sie korrekt versteht. Lineare Regression erwartet ein 2D-Array als Eingabe, wobei jede Zeile des Arrays einem Vektor von Eingabewerten entspricht. In unserem Fall, da wir nur ein Eingabewert haben, brauchen wir ein Array mit der Form N×1, wobei N die Größe des Datensatzes ist.

Dann müssen wir die Daten in Trainings- und Testdatensätze aufteilen, damit wir unser Modell nach dem Training validieren können:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

Schließlich dauert das eigentliche Training des linearen Regressionsmodells nur zwei Codezeilen. Wir definieren das LinearRegression-Objekt und passen es mit der fit-Methode an unsere Daten an:

lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)

Das LinearRegression-Objekt enthält nach dem fit-ten alle Koeffizienten der Regression, auf die über die Eigenschaft .coef_ zugegriffen werden kann. In unserem Fall gibt es nur einen Koeffizienten, der ungefähr -0,017 betragen sollte. Das bedeutet, dass die Preise mit der Zeit etwas zu sinken scheinen, aber nicht zu stark, ungefähr 2 Cent pro Tag. Wir können auch den Schnittpunkt der Regression mit der Y-Achse mithilfe von lin_reg.intercept_ abrufen – dieser wird in unserem Fall etwa 21 betragen und zeigt den Preis am Anfang des Jahres an.

Um zu sehen, wie genau unser Modell ist, können wir Preise in einem Testdatensatz vorhersagen und dann messen, wie nah unsere Vorhersagen an den erwarteten Werten sind. Dies kann mittels Root Mean Square Error (RMSE) geschehen, das die Wurzel aus dem Mittelwert aller quadrierten Differenzen zwischen erwartetem und vorhergesagtem Wert ist.

pred = lin_reg.predict(X_test)

rmse = np.sqrt(mean_squared_error(y_test,pred))
print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')

Unser Fehler scheint bei etwa 2 Punkten zu liegen, was ca. 17 % entspricht. Nicht allzu gut. Ein weiterer Indikator für die Modellqualität ist der Bestimmtheitsmaß, der folgendermaßen ermittelt werden kann:

score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)

Wenn der Wert 0 ist, bedeutet dies, dass das Modell die Eingabedaten nicht berücksichtigt und als schlechtester linearer Prädiktor fungiert, was einfach dem Mittelwert des Ergebnisses entspricht. Ein Wert von 1 bedeutet, dass wir alle erwarteten Ausgaben perfekt vorhersagen können. In unserem Fall liegt der Koeffizient bei etwa 0,06, was recht niedrig ist.

Wir können auch die Testdaten zusammen mit der Regressionslinie plotten, um besser zu sehen, wie die Regression in unserem Fall funktioniert:

plt.scatter(X_test,y_test)
plt.plot(X_test,pred)

Polynomiale Regression

Eine andere Art der linearen Regression ist die Polynomiale Regression. Während es manchmal eine lineare Beziehung zwischen Variablen gibt – je größer der Kürbis im Volumen, desto höher der Preis – können diese Beziehungen manchmal nicht als Ebene oder Gerade dargestellt werden.

✅ Hier sind weitere Beispiele für Daten, die eine polynomiale Regression benötigen könnten.

Schauen Sie sich die Beziehung zwischen Datum und Preis noch einmal an. Sollte dieses Streudiagramm zwangsläufig durch eine Gerade analysiert werden? Können die Preise nicht schwanken? In solchen Fällen kann man polynomiale Regression versuchen.

✅ Polynome sind mathematische Ausdrücke, die aus einer oder mehreren Variablen und Koeffizienten bestehen können.

Die polynomiale Regression erstellt eine gekrümmte Linie, um besser zu nichtlinearen Daten zu passen. In unserem Fall sollten wir durch Einbeziehung einer quadrierten DayOfYear-Variable in die Eingabedaten in der Lage sein, unsere Daten mit einer parabolischen Kurve anzupassen, die an einem bestimmten Punkt innerhalb des Jahres ein Minimum hat.

Scikit-learn bietet eine hilfreiche Pipeline-API, um verschiedene Verarbeitungsschritte zusammenzuführen. Eine Pipeline ist eine Kette von Estimatoren. In unserem Fall erstellen wir eine Pipeline, die zuerst polynomiale Merkmale zum Modell hinzufügt und dann die Regression trainiert:

from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline

pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())

pipeline.fit(X_train,y_train)

Die Verwendung von PolynomialFeatures(2) bedeutet, dass wir alle Polynome zweiten Grades aus den Eingabedaten einschließen. In unserem Fall bedeutet das nur DayOfYear², aber bei zwei Eingabevariablen X und Y werden zusätzlich X², XY und Y² hinzugefügt. Wir können auch Polynome höheren Grades verwenden, wenn wir möchten.

Pipelines können auf die gleiche Weise wie das ursprüngliche LinearRegression-Objekt verwendet werden, d.h. wir können die Pipeline fit-ten und dann predict aufrufen, um Vorhersagen zu erhalten:

pred = pipeline.predict(X_test)

rmse = np.sqrt(mean_squared_error(y_test,pred))
print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')

score = pipeline.score(X_train,y_train)
print('Model determination: ', score)

Um die glatte Annäherungskurve zu zeichnen, verwenden wir np.linspace, um einen gleichmäßigen Bereich von Eingabewerten zu erzeugen, anstatt direkt die ungeordneten Testdaten zu verwenden (was eine Zickzacklinie ergeben würde):

X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)
y_range = pipeline.predict(X_range)

plt.scatter(X_test, y_test)
plt.plot(X_range, y_range)

Hier ist der Graph, der Testdaten und die Annäherungskurve zeigt:

Mit polynomieller Regression können wir etwas geringeren RMSE und höhere Bestimmtheitsmaße erzielen, aber nicht signifikant. Wir müssen weitere Merkmale berücksichtigen!

Sie können sehen, dass die minimalen Kürbiskurse irgendwo um Halloween beobachtet werden. Wie können Sie das erklären?

🎃 Herzlichen Glückwunsch, Sie haben gerade ein Modell erstellt, das dabei helfen kann, den Preis von Backkürbissen vorherzusagen. Wahrscheinlich können Sie dasselbe Verfahren für alle Kürbissorten wiederholen, aber das wäre mühsam. Lernen wir nun, wie wir die Kürbissorte in unser Modell einbeziehen!

Kategorische Merkmale

In der idealen Welt wollen wir Preise für verschiedene Kürbissorten mit demselben Modell vorhersagen können. Die Spalte Variety unterscheidet sich jedoch etwas von Spalten wie Month, da sie nicht-numerische Werte enthält. Solche Spalten nennt man kategorisch.

🎥 Klicken Sie auf das Bild oben für eine kurze Videoübersicht zum Umgang mit kategorialen Merkmalen.

Hier sehen Sie, wie der Durchschnittspreis von der Sorte abhängt:

Um die Sorte zu berücksichtigen, müssen wir sie zunächst in numerische Form umwandeln oder kodieren. Es gibt verschiedene Vorgehensweisen:

• Eine einfache numerische Kodierung erstellt eine Tabelle der verschiedenen Sorten und ersetzt dann den Sortennamen durch einen Index in dieser Tabelle. Das ist keine gute Idee für lineare Regression, weil das Modell den tatsächlichen numerischen Wert des Index nimmt und mit einem Koeffizienten multipliziert zum Ergebnis hinzufügt. In unserem Fall ist die Beziehung zwischen dem Index und dem Preis eindeutig nicht-linear, selbst wenn wir sicherstellen, dass die Indizes in einer bestimmten Reihenfolge angeordnet sind.
• One-Hot-Kodierung ersetzt die Spalte Variety durch 4 verschiedene Spalten, je eine für jede Sorte. Jede Spalte enthält 1, wenn die entsprechende Zeile diese Sorte hat, und 0 sonst. Das bedeutet, dass es vier Koeffizienten in der linearen Regression gibt, einen für jede Kürbissorte, der für den „Startpreis“ (bzw. „zusätzlichen Preis“) für diese Sorte verantwortlich ist.

Der folgende Code zeigt, wie wir eine Sorte als One-Hot kodieren können:

pd.get_dummies(new_pumpkins['Variety'])

ID	FAIRYTALE	MINIATURE	MIXED HEIRLOOM VARIETIES	PIE TYPE
70	0	0	0	1
71	0	0	0	1
...	...	...	...	...
1738	0	1	0	0
1739	0	1	0	0
1740	0	1	0	0
1741	0	1	0	0
1742	0	1	0	0

Um lineare Regression mit der One-Hot-kodierten Sorte als Eingabe zu trainieren, müssen wir nur die Daten in X und y richtig initialisieren:

X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']

Der Rest des Codes ist derselbe wie oben für das Training der linearen Regression. Wenn Sie es ausprobieren, werden Sie sehen, dass der mittlere quadratische Fehler ungefähr gleich bleibt, wir aber eine deutlich höhere Bestimmtheitsmaßzahl (~77 %) erhalten. Für noch genauere Vorhersagen können wir weitere kategoriale Merkmale sowie numerische Merkmale wie Month oder DayOfYear einbeziehen. Um ein großes Merkmal-Array zu erhalten, können wir join verwenden:

X = pd.get_dummies(new_pumpkins['Variety']) \
        .join(new_pumpkins['Month']) \
        .join(pd.get_dummies(new_pumpkins['City'])) \
        .join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']

Hier berücksichtigen wir auch City und Package-Typ, was uns einen RMSE von 2,84 (10,5 %) und eine Bestimmtheitsmaßzahl von 0,94 gibt!

Alles zusammenführen

Um das beste Modell zu erstellen, können wir kombinierte (one-hot-kodierte kategoriale + numerische) Daten aus dem obigen Beispiel zusammen mit Polynomialer Regression verwenden. Hier ist der vollständige Code zu Ihrer Bequemlichkeit:

# Trainingsdaten einrichten
X = pd.get_dummies(new_pumpkins['Variety']) \
        .join(new_pumpkins['Month']) \
        .join(pd.get_dummies(new_pumpkins['City'])) \
        .join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']

# Trainings- und Testdaten aufteilen
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# Pipeline einrichten und trainieren
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)

# Ergebnisse für Testdaten vorhersagen
pred = pipeline.predict(X_test)

# RMSE und Bestimmtheitsmaß berechnen
rmse = mean_squared_error(y_test, pred, squared=False)
print(f'RMSE: {rmse:3.3} ({rmse/pred.mean()*100:3.3}%)')

score = pipeline.score(X_train,y_train)
print('Model determination: ', score)

Damit sollten wir den besten Bestimmtheitsmaß von fast 97 % und RMSE = 2,23 (~8 % Vorhersagefehler) erhalten.

Modell	RMSE	Bestimmtheitsmaß
DayOfYear Linear	2,77 (17,2 %)	0,07
DayOfYear Polynomial	2,73 (17,0 %)	0,08
Variety Linear	5,24 (19,7 %)	0,77
Alle Merkmale Linear	2,84 (10,5 %)	0,94
Alle Merkmale Polynomial	2,23 (8,25 %)	0,97

🏆 Gut gemacht! Sie haben in einer Lektion vier Regressionsmodelle erstellt und die Modellqualität auf 97 % verbessert. Im abschließenden Abschnitt über Regression lernen Sie logistische Regression kennen, um Kategorien zu bestimmen.

---

🚀Herausforderung

Testen Sie in diesem Notebook verschiedene Variablen, um zu sehen, wie Korrelation mit der Modellgenauigkeit zusammenhängt.

Quiz nach der Vorlesung

Wiederholung & Selbststudium

In dieser Lektion haben wir über Lineare Regression gelernt. Es gibt noch andere wichtige Regressionstypen. Lesen Sie über Stepwise-, Ridge-, Lasso- und Elasticnet-Techniken. Ein guter Kurs zum Weiterlernen ist der Stanford Statistical Learning Course

Aufgabe

Ein Modell erstellen

---

Haftungsausschluss:
Dieses Dokument wurde mit dem KI-Übersetzungsdienst Co-op Translator übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache ist als maßgebliche Quelle anzusehen. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die durch die Nutzung dieser Übersetzung entstehen.