Maschinelles Lernen für Softwareentwickler

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.

Beim 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 (Inputs) und Preisen (Outputs). 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. Lassen Sie uns also eine andere Methode erkunden: den Gradientenabstieg.

Gefälleabstieg

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 uns entgegen der Richtung des Gefälles bewegen, nähern wir uns dem tiefsten Punkt.

So funktioniert es:

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 Gewichte, 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 Gewichtssatz 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 dem leicht erhöhten Gewicht.

• Berechnen Sie die Steigung (Steigung):

   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 new_error > original_error, der Gradient ist positiv, was bedeutet, dass eine Erhöhung dieses Gewichts den Fehler erhöht.
• Wenn new_error < original_error, der Gradient ist negativ, was bedeutet, dass eine Erhöhung dieses Gewichts den Fehler verringert.

• 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.

This is called "numerical gradient calculation" or "finite difference method". We're approximating the gradient instead of calculating it analytically.

Let's update the weights

Now that we have our gradients, we can push our weights in the opposite direction of the gradient by subtracting the gradient.

weights[i] -= gradients[i]

If our gradient is too large, we could easily overshoot our minimum by updating our weight too much. To fix this, we can multiply the gradient by some small number:

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

And so here is how we do it for all of the weights:

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

Finally, we have our weights!

Interpreting the Model

Once we have our trained weights, we can use them to interpret our model:

• The weight for 'sqft' represents the price increase per square foot.
• The weight for 'bedrooms' represents the price increase per additional bedroom.
• The weight for 'baths' represents the price increase per additional bathroom.

For example, if our trained weights are [100, 10000, 15000], it means:

• Each square foot adds $100 to the home price.
• Each bedroom adds $10,000 to the home price.
• Each bathroom adds $15,000 to the home price.

Linear models, despite their simplicity, are powerful tools in machine learning. They provide a foundation for understanding more complex algorithms and offer interpretable insights into real-world problems.

Das obige ist der detaillierte Inhalt vonMaschinelles Lernen für Softwareentwickler. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!