Lassen Sie mich wissen, wenn Sie das wertvoll finden, und ich werde weitermachen!

Kapitel 1 – Das lineare Modell

Eines der einfachsten und dennoch wirkungsvollsten Konzepte ist das lineare Modell.

In ML besteht eines unserer Hauptziele darin, Vorhersagen auf der Grundlage von Daten zu treffen. Das lineare Modell ist wie die „Hallo Welt“ des maschinellen Lernens – es ist unkompliziert, bildet aber die Grundlage für das Verständnis komplexerer Modelle.

Lassen Sie uns ein Modell erstellen, um Immobilienpreise vorherzusagen. In diesem Beispiel ist die Ausgabe der erwartete „Hauspreis“, und Ihre Eingaben sind Dinge wie „Quadratmeter“, „Anzahl_Schlafzimmer“ usw. …

def prediction(sqft, num_bedrooms, num_baths):
    weight_1, weight_2, weight_3 = .0, .0, .0  
    home_price = weight_1*sqft, weight_2*num_bedrooms, weight_3*num_baths
    return home_price

Sie werden für jede Eingabe eine „Gewichtung“ bemerken. Diese Gewichte machen die Magie hinter der Vorhersage aus. Dieses Beispiel ist langweilig, da es immer Null ausgibt, da die Gewichte Null sind.

Lassen Sie uns also herausfinden, wie wir diese Gewichte finden können.

Gewichte finden

Der Prozess zum Finden der Gewichte wird als „Training“ des Modells bezeichnet.

• Zunächst benötigen wir einen Datensatz von Häusern mit bekannten Merkmalen (Eingaben) und Preisen (Ausgaben). Zum Beispiel:

data = [
    {"sqft": 1000, "bedrooms": 2, "baths": 1, "price": 200000},
    {"sqft": 1500, "bedrooms": 3, "baths": 2, "price": 300000},
    # ... more data points ...
]

• Bevor wir eine Möglichkeit entwickeln, unsere Gewichte zu aktualisieren, müssen wir wissen, wie weit unsere Vorhersagen abweichen. Wir können die Differenz zwischen unserer Vorhersage und dem tatsächlichen Wert berechnen.

home_price = prediction(1000, 2, 1) # our weights are currently zero, so this is zero
actual_value = 200000

error = home_price - actual_value # 0 - 200000 we are way off. 
# let's square this value so we aren't dealing with negatives
error = home_price**2

Da wir nun wissen, wie weit (Fehler) wir bei einem Datenpunkt abweichen, können wir den durchschnittlichen Fehler über alle Datenpunkte berechnen. Dies wird üblicherweise als mittlerer quadratischer Fehler bezeichnet.

• Aktualisieren Sie abschließend die Gewichte so, dass der mittlere quadratische Fehler verringert wird.

Wir könnten natürlich Zufallszahlen wählen und im Laufe der Zeit immer den besten Wert speichern – aber das ist ineffizient. Schauen wir uns also eine andere Methode an: den Gradientenabstieg.

Gradientenabstieg

Gradient Descent ist ein Optimierungsalgorithmus, der verwendet wird, um die besten Gewichte für unser Modell zu finden.

Der Gradient ist ein Vektor, der uns sagt, wie sich der Fehler ändert, wenn wir an jeder Gewichtung kleine Änderungen vornehmen.

Sidebar-Intuition
Stellen Sie sich vor, Sie stehen in einer hügeligen Landschaft und Ihr Ziel ist es, den tiefsten Punkt (den minimalen Fehler) zu erreichen. Das Gefälle ist wie ein Kompass, der immer auf den steilsten Anstieg zeigt. Indem wir entgegen der Richtung des Gefälles gehen, machen wir Schritte in Richtung des tiefsten Punktes.

So funktioniert das:

1. Beginnen Sie mit zufälligen Gewichtungen (oder Nullen).
2. Berechnen Sie den Fehler für die aktuellen Gewichte.
3. Berechnen Sie den Gradienten (Steigung) des Fehlers für jedes Gewicht.
4. Aktualisieren Sie die Gewichtungen, indem Sie einen kleinen Schritt in die Richtung bewegen, die den Fehler verringert.
5. Wiederholen Sie die Schritte 2–4, bis der Fehler nicht mehr deutlich abnimmt.

Wie berechnen wir den Gradienten für jeden Fehler?

Eine Möglichkeit, den Gradienten zu berechnen, besteht darin, kleine Gewichtsverschiebungen vorzunehmen, zu sehen, wie sich das auf unseren Fehler auswirkt, und zu sehen, wohin wir uns von dort aus bewegen sollten.

def calculate_gradient(weight, data, feature_index, step_size=1e-5):
    original_error = calculate_mean_squared_error(weight, data)

    # Slightly increase the weight
    weight[feature_index]  = step_size
    new_error = calculate_mean_squared_error(weight, data)

    # Calculate the slope
    gradient = (new_error - original_error) / step_size

    # Reset the weight
    weight[feature_index] -= step_size

    return gradient

Schritt-für-Schritt-Anleitung

• Eingabeparameter:

  • Gewicht: Der aktuelle Satz von Gewichten für unser Modell.
  • Daten: Unser Datensatz mit Hausmerkmalen und -preisen.
  • feature_index: Das Gewicht, für das wir den Gradienten berechnen (0 für Quadratfuß, 1 für Schlafzimmer, 2 für Bäder).
  • step_size: Ein kleiner Wert, den wir verwenden, um die Gewichtung leicht zu ändern (Standard ist 1e-5 oder 0,00001).

• Ursprünglichen Fehler berechnen:
  
  

   original_error = calculate_mean_squared_error(weight, data)

Wir berechnen zunächst den mittleren quadratischen Fehler mit unseren aktuellen Gewichten. Das gibt uns unseren Ausgangspunkt.

• Gewicht leicht erhöhen:

   weight[feature_index]  = step_size

Wir erhöhen das Gewicht um einen kleinen Betrag (step_size). Dadurch können wir sehen, wie sich eine kleine Gewichtsänderung auf unseren Fehler auswirkt.

• Neuen Fehler berechnen:

   new_error = calculate_mean_squared_error(weight, data)

Wir berechnen den mittleren quadratischen Fehler erneut mit der leicht erhöhten Gewichtung.

• Berechnen Sie die Steigung (Gradient):

   gradient = (new_error - original_error) / step_size

Dies ist der entscheidende Schritt. Wir fragen: „Wie sehr hat sich der Fehler verändert, als wir das Gewicht leicht erhöht haben?“

• Wenn neuer_Fehler > Original_Fehler, ist der Gradient positiv, was bedeutet, dass eine Erhöhung dieser Gewichtung den Fehler erhöht.
• Wenn new_error

• Die Größe sagt uns, wie empfindlich der Fehler auf Änderungen dieses Gewichts reagiert.

  • Gewicht zurücksetzen:

   weight[feature_index] -= step_size

Wir haben das Gewicht auf seinen ursprünglichen Wert zurückgesetzt, da wir getestet haben, was passieren würde, wenn wir es ändern würden.

• Den Farbverlauf zurückgeben:

   return gradient

Wir geben den berechneten Gradienten für dieses Gewicht zurück.

Dies wird als „numerische Gradientenberechnung“ oder „Finite-Differenzen-Methode“ bezeichnet. Wir nähern uns dem Gradienten an, anstatt ihn analytisch zu berechnen.

Lassen Sie uns die Gewichte aktualisieren

Da wir nun unsere Farbverläufe haben, können wir unsere Gewichte in die entgegengesetzte Richtung des Farbverlaufs verschieben, indem wir den Farbverlauf subtrahieren.

weights[i] -= gradients[i]

Wenn unser Gradient zu groß ist, könnten wir leicht unser Minimum überschreiten, indem wir unser Gewicht zu stark aktualisieren. Um dies zu beheben, können wir den Farbverlauf mit einer kleinen Zahl multiplizieren:

learning_rate = 0.00001
weights[i] -= learning_rate*gradients[i]

Und so machen wir es für alle Gewichte:

def gradient_descent(data, learning_rate=0.00001, num_iterations=1000):
    weights = [0, 0, 0]  # Start with zero weights

    for _ in range(num_iterations):
        gradients = [
            calculate_gradient(weights, data, 0), # sqft
            calculate_gradient(weights, data, 1), # bedrooms
            calculate_gradient(weights, data, 2)  # bathrooms
        ]

        # Update each weight
        for i in range(3):
            weights[i] -= learning_rate * gradients[i]

        if _ % 100 == 0:
            error = calculate_mean_squared_error(weights, data)
            print(f"Iteration {_}, Error: {error}, Weights: {weights}")

    return weights

Endlich haben wir unsere Gewichte!

Interpretation des Modells

Sobald wir unsere trainierten Gewichte haben, können wir sie zur Interpretation unseres Modells verwenden:

• Das Gewicht für „sqft“ stellt die Preissteigerung pro Quadratfuß dar.
• Die Gewichtung für „Schlafzimmer“ stellt die Preiserhöhung pro zusätzlichem Schlafzimmer dar.
• Das Gewicht für „Bäder“ stellt die Preiserhöhung pro zusätzlichem Badezimmer dar.

Wenn unsere trainierten Gewichte beispielsweise [100, 10000, 15000] sind, bedeutet das:

• Jeder Quadratfuß erhöht den Hauspreis um 100 $.
• Jedes Schlafzimmer erhöht den Hauspreis um 10.000 $.
• Jedes Badezimmer erhöht den Hauspreis um 15.000 US-Dollar.

Lineare Modelle sind trotz ihrer Einfachheit leistungsstarke Werkzeuge beim maschinellen Lernen. Sie bilden eine Grundlage für das Verständnis komplexerer Algorithmen und bieten interpretierbare Einblicke in reale Probleme.