0Pricing
Machine Learning Academy · Lektion

Die Geradengleichung: Steigung, Achsenabschnitt und Vorhersagen

Rufen Sie sich die Formel y=mx+b ins Gedächtnis, zeichnen Sie eine Regressionsgerade für reale Daten und verstehen Sie, wie das Modell Eingaben auf Ausgaben abbildet.

Die Geradengleichung: Steigung, Achsenabschnitt und Vorhersagen ist eine kostenlose Machine Learning Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Machine Learning Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Machine Learning Academy-Kurs umfasst insgesamt 4 Lektionen.

Linear Relationships in Data

Viele reale Beziehungen sind näherungsweise linear: Mit zunehmender Quadratmeterzahl steigt der Hauspreis proportional; mit steigenden Werbeausgaben steigen die Umsätze. Die lineare Regression modelliert diese Beziehungen, indem sie die Gerade findet, die am besten zu den Daten passt.

Bevor Sie sich mit dem Algorithmus befassen, müssen Sie das mathematische Objekt, das er zu finden versucht, genau verstehen: die Gleichung einer Geraden. Jedes lineare Regressionsmodell ist letztendlich eine Gerade (in 2D) oder eine Hyperebene (in höheren Dimensionen), und die beiden Parameter, die sie definieren – Steigung und Achsenabschnitt –, haben aussagekräftige Interpretationen für das Problem, das Sie lösen.

The Equation y = mx + b

Die Gleichung einer Geraden in 2D lautet y = mx + b, wobei:

  • y — die abhängige Variable (was wir vorhersagen möchten, z. B. Hauspreis)
  • x — die unabhängige Variable oder das Merkmal (z. B. Wohnfläche in Quadratfuß)
  • m — die Steigung: wie stark sich y bei jeder Erhöhung von x um eine Einheit verändert
  • b — der Achsenabschnitt (Intercept): der Wert von y, wenn x null ist

In der Notation des maschinellen Lernens wird dies oft als ŷ = w₁x + w₀ oder ŷ = θ₁x + θ₀ geschrieben, wobei w oder θ die Gewichte (Parameter) sind, die das Modell lernt.

import numpy as np
import matplotlib.pyplot as plt

# Define a line: y = 2x + 5
m = 2.0   # slope
b = 5.0   # intercept

x = np.linspace(0, 10, 100)
y = m * x + b  # vectorised — computes all 100 points at once

plt.plot(x, y, color='blue', linewidth=2)
plt.xlabel('x (square footage / 100)')
plt.ylabel('y (price in $1000s)')
plt.title('Line: y = 2x + 5')
plt.grid(True, alpha=0.3)
plt.show()

Interpreting the Slope

Die Steigung m gibt die Änderungsrate an: Für jede Zunahme von x um eine Einheit verändert sich y um m Einheiten. Das Vorzeichen ist wichtig: Eine positive Steigung bedeutet, dass sich x und y gemeinsam bewegen (positive Korrelation), eine negative Steigung bedeutet, dass sie sich in entgegengesetzte Richtungen bewegen.

In einem Hauspreismodell, in dem x die Quadratmeterzahl und y der Preis in Dollar ist, bedeutet eine Steigung von 150, dass jeder zusätzliche Quadratmeter den vorhergesagten Preis um 150 $ erhöht. Diese Interpretierbarkeit ist eine der größten Stärken der linearen Regression – Sie können genau erklären, was die Vorhersage antreibt.

import numpy as np

# Example: house price model
# y = 150 * sqft + 50000

def predict_price(sqft, slope=150, intercept=50000):
    return slope * sqft + intercept

print('Price for 1000 sqft:', predict_price(1000))  # $200,000
print('Price for 1500 sqft:', predict_price(1500))  # $275,000
print('Price for 2000 sqft:', predict_price(2000))  # $350,000

# Each 500 sqft increase adds:
delta = predict_price(1500) - predict_price(1000)
print(f'Adding 500 sqft increases price by: ${delta:,}')

Interpreting the Intercept

Der Achsenabschnitt b ist der Wert von y, wenn x gleich Null ist. Er verankert die Gerade an einem bestimmten y-Wert auf der vertikalen Achse. Die Interpretation des Achsenabschnitts erfordert Sorgfalt – manchmal ergibt sie physikalisch Sinn und manchmal nicht.

Im Beispiel mit den Hauspreisen würde ein Achsenabschnitt von 50.000 $ bedeuten, dass ein Haus mit einer Wohnfläche von null Quadratmetern 50.000 $ kostet, was physikalisch keinen Sinn ergibt. Der Achsenabschnitt ist am besten als Kalibrierungskonstante zu verstehen, die die gesamte Gerade nach oben oder unten verschiebt, um sie an die Daten anzupassen, und nicht als Größe mit direktem realen Sinn in jedem Kontext.

import numpy as np
import matplotlib.pyplot as plt

x = np.array([500, 800, 1000, 1200, 1500, 2000])
y = np.array([125000, 170000, 200000, 230000, 275000, 350000])

# The intercept shifts the line vertically
for intercept in [0, 50000, 100000]:
    y_line = 150 * np.linspace(0, 2000, 100) + intercept
    plt.plot(np.linspace(0, 2000, 100), y_line,
             label=f'b = {intercept:,}')

plt.scatter(x, y, color='black', zorder=5, label='Data')
plt.xlabel('Square Footage')
plt.ylabel('Price ($)')
plt.legend()
plt.show()

Plotting Data and a Regression Line

Bevor Sie ein Modell anpassen, sollten Sie immer Ihre Daten plotten, um zu bestätigen, dass tatsächlich ein linearer Zusammenhang besteht. Wenn das Streudiagramm ein gekrümmtes oder nichtlineares Muster zeigt, ist ein lineares Modell die falsche Wahl. Das Visualisieren der angepassten Linie über dem Streudiagramm ist der erste Validierungsschritt nach dem Training.

Seaborns regplot() berechnet und plottet die Regressionsgerade mit einem Konfidenzintervall in einem einzigen Aufruf, was es zu einer schnellen Plausibilitätsprüfung während der EDA macht.

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Simulate house price data
np.random.seed(42)
sqft = np.random.uniform(500, 3000, 100)
price = 150 * sqft + 50000 + np.random.normal(0, 20000, 100)

# Quick regression plot with seaborn
plt.figure(figsize=(8, 5))
sns.regplot(x=sqft, y=price, scatter_kws={'alpha': 0.5},
            line_kws={'color': 'red', 'linewidth': 2})
plt.xlabel('Square Footage')
plt.ylabel('Price ($)')
plt.title('House Price vs Square Footage')
plt.show()

Making Predictions with a Line

Sobald Sie eine Gerade haben (Steigung m und Achsenabschnitt b), ist das Treffen einer Vorhersage für eine neue Eingabe x reine Arithmetik: Setzen Sie x in die Gleichung ein und berechnen Sie y. Dies wird als Inferenz oder Vorhersage bezeichnet.

Die entscheidende Erkenntnis ist, dass das Modell den wahren Ausgang für eine neue Eingabe nicht kennt – es schätzt ihn basierend auf den Mustern, die es aus den Trainingsdaten gelernt hat. Die Qualität dieser Vorhersagen hängt vollständig davon ab, wie gut die Trainingsdata die neuen Eingaben repräsentieren und wie linear der wahre Zusammenhang tatsächlich ist.

import numpy as np

# Learned parameters (from training, simplified here)
slope = 150.0
intercept = 52000.0

def predict(x_new, m, b):
    return m * x_new + b

# Single prediction
new_house_sqft = 1800
predicted_price = predict(new_house_sqft, slope, intercept)
print(f'Predicted price for {new_house_sqft} sqft: ${predicted_price:,.0f}')

# Batch prediction (multiple houses)
houses = np.array([1000, 1200, 1500, 2000, 2500])
prices = predict(houses, slope, intercept)
for sqft, price in zip(houses, prices):
    print(f'{sqft} sqft -> ${price:,.0f}')

Residuals: The Gap Between Prediction and Reality

Kein echter Datensatz liegt perfekt auf einer Geraden. Das Residuum für jeden Datenpunkt ist die Differenz zwischen dem tatsächlichen Wert und dem vom Modell vorhergesagten Wert: Residuum = y_tatsächlich - y_vorhergesagt. Ein positives Residuum bedeutet, dass das Modell den Wert unterschätzt hat; ein negatives Residuum bedeutet, dass es ihn überschätzt hat.

Residuen sind das Rohmaterial für die Bewertung und Verbesserung eines linearen Modells. Wenn Residuen ein systematisches Muster zeigen (z. B. immer positiv für große x-Werte), ist das ein Beleg dafür, dass die wahre Beziehung nichtlinear ist und ein komplexeres Modell erforderlich ist.

import numpy as np

y_actual = np.array([200000, 250000, 310000, 180000, 420000])

# Model predictions
m, b = 150.0, 52000.0
x = np.array([1000, 1300, 1700, 850, 2400])
y_pred = m * x + b

residuals = y_actual - y_pred

for i, (actual, pred, res) in enumerate(zip(y_actual, y_pred, residuals)):
    print(f'House {i+1}: Actual=${actual:,}  Predicted=${pred:,.0f}  Residual=${res:,.0f}')

print(f'\nMean residual: ${residuals.mean():,.0f}')
print(f'Std of residuals: ${residuals.std():,.0f}')

Negative Slope: Inverse Relationships

Eine negative Steigung modelliert eine inverse Beziehung: Wenn x zunimmt, nimmt y ab. Zum Beispiel: Je älter ein Auto, desto geringer ist sein Wiederverkaufswert. Oder je mehr Mitbewerber ein Unternehmen hat, desto geringer ist sein Marktanteil.

Die lineare Regression verarbeitet negative Steigungen ganz natürlich – der Algorithm findet genau die Steigung (positiv, negativ oder null), die am besten zu den Trainingsdaten passt. Eine Steigung von genau null würde bedeuten, dass x keine Informationen über y liefert und die beste Vorhersage für jeden Eingang einfach der Mittelwert von y wäre.

import numpy as np
import matplotlib.pyplot as plt

# Car age vs resale value (inverse relationship)
np.random.seed(0)
age = np.random.uniform(1, 15, 50)
value = -1500 * age + 25000 + np.random.normal(0, 2000, 50)
value = np.clip(value, 1000, 30000)  # clip to realistic range

plt.scatter(age, value, alpha=0.6)
plt.plot([1, 15], [-1500*1+25000, -1500*15+25000],
         color='red', linewidth=2, label='y = -1500x + 25000')
plt.xlabel('Car Age (years)')
plt.ylabel('Resale Value ($)')
plt.title('Inverse Relationship: Age vs Resale Value')
plt.legend()
plt.show()

From Line to Hyperplane

In der Realität haben wir fast immer mehrere Eingabemerkmale und nicht nur eines. Wenn Sie die Geradengleichung auf mehrere Merkmale erweitern, wird das Modell zu einer Hyperebene im hochdimensionalen Raum:

ŷ = w₁x₁ + w₂x₂ + ... + wₙxₙ + b

Jedes wᵢ ist ein separater Koeffizient (Gewicht) für das entsprechende Merkmal xᵢ. Die Vorhersage ist nach wie vor nur eine Linearkombination der Eingaben plus einem Bias. Diese Erweiterung – von einer Geraden zu einer Hyperebene – ist alles, was sich ändert, wenn Sie von der einfachen zur multiplen linearen Regression übergehen.

import numpy as np

# Multiple linear regression prediction
# y = w1*sqft + w2*bedrooms + w3*age + b

def predict_multi(features, weights, bias):
    # features shape: (n_features,) or (n_samples, n_features)
    return np.dot(features, weights) + bias

weights = np.array([150.0, 5000.0, -200.0])  # sqft, bedrooms, age
bias = 30000.0

# One house: 1500 sqft, 3 bedrooms, 10 years old
house = np.array([1500, 3, 10])
price = predict_multi(house, weights, bias)
print(f'Predicted price: ${price:,.0f}')
# = 150*1500 + 5000*3 + (-200)*10 + 30000 = $282,000

Correlation vs Causation in Linear Models

Lineare Regression findet statistische Korrelationen, keine kausalen Zusammenhänge. Eine hohe Steigung zwischen Eisverkäufen und Ertrinkungstoten bedeutet nicht, dass Eiscreme zum Ertrinken führt – beides wird durch heißes Wetter verursacht. Die Steigung eines Modells informiert über die Beziehung in den Trainingsdaten, nicht über den zugrundeliegenden kausalen Mechanismus.

Dieser Unterschied ist von enormer Wichtigkeit, wenn ML-Modelle für die Entscheidungsfindung eingesetzt werden. Ein Modell, das Kreditausfälle vorhersagt, stellt möglicherweise fest, dass die Postleitzahl ein starker Prädiktor ist – aber die Verwendung der Postleitzahl als Entscheidungsfaktor kann rassistische Diskriminierung anstelle eines echten Kreditrisikos verschlüsseln. Hinterfragen Sie immer, warum ein Merkmal eine hohe Vorhersagekraft hat.

Setting Up for scikit-learn

Jetzt, da Sie wissen, was eine Gerade ist und was ihre Parameter bedeuten, sind Sie bereit, scikit-learn zu verwenden, um die optimale Steigung und den y-Achsenabschnitt automatisch aus Daten zu lernen. Der Algorithmus minimiert den gesamten Vorhersagefehler über alle Trainingsbeispiele hinweg und findet die Ausgleichsgerade, ohne dass Sie m und b manuell anpassen müssen.

In der nächsten Lektion lernen Sie genau, wie diese Optimierung funktioniert – was „beste Anpassung“ mathematisch bedeutet und wie die Kostenfunktion des mittleren quadratischen Fehlers (Mean Squared Error) das Anpassen einer Geraden in ein Problem der Minimierung eines mathematischen Ausdrucks verwandelt.

from sklearn.linear_model import LinearRegression
import numpy as np

# scikit-learn finds the optimal slope and intercept automatically
np.random.seed(42)
sqft = np.random.uniform(500, 3000, 100).reshape(-1, 1)
price = 150 * sqft.ravel() + 50000 + np.random.normal(0, 20000, 100)

model = LinearRegression()
model.fit(sqft, price)

print(f'Learned slope (coef_):     {model.coef_[0]:.1f}')
print(f'Learned intercept (b):     {model.intercept_:.1f}')
print(f'Prediction for 1500 sqft: ${model.predict([[1500]])[0]:,.0f}')

Quick Check

Überprüfen Sie Ihr Verständnis der Konzepte zu Machine Learning mit Python aus dieser Lektion.

Lesson Recap

In dieser Lektion hast du gelernt: die Gleichung y=mx+b definiert eine Gerade mit der Steigung m (Änderungsrate) und dem Achsenabschnitt b (y-Wert bei x=0), Residuen messen den Abstand zwischen tatsächlichen und vorhergesagten Werten, und die multiple lineare Regression erweitert die Gerade auf eine Hyperebene mit einem Gewicht pro Merkmal. Als Nächstes erforschen wir Kostenfunktionen und die Methode der kleinsten Quadrate – das mathematische Framework, das definiert, was „beste Anpassung“ bedeutet und wie der Algorithmus die optimalen Parameter findet.

Häufig gestellte Fragen

Ist die Lektion „Die Geradengleichung: Steigung, Achsenabschnitt und Vorhersagen“ kostenlos?

Ja — der vollständige Text von „Die Geradengleichung: Steigung, Achsenabschnitt und Vorhersagen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Machine Learning Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Machine Learning Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Die Geradengleichung: Steigung, Achsenabschnitt und Vorhersagen“?

Rufen Sie sich die Formel y=mx+b ins Gedächtnis, zeichnen Sie eine Regressionsgerade für reale Daten und verstehen Sie, wie das Modell Eingaben auf Ausgaben abbildet. Du übst Machine Learning Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Machine Learning Academy zu starten?

Keine Vorkenntnisse erforderlich. Machine Learning Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Die Geradengleichung: Steigung, Achsenabschnitt und Vorhersagen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Machine Learning Academy-Lektion Code schreiben und ausführen?

Ja. Jede Machine Learning Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Die Geradengleichung: Steigung, Achsenabschnitt und Vorhersagen
  2. Kostenfunktionen und kleinste Quadrate
  3. Lineare Regression mit scikit-learn trainieren
  4. Multiple lineare Regression und Feature-Wichtigkeit
← Zurück zu Machine Learning Academy